void proto_register_mswsp ( void ) {
 expert_module_t * expert_mswsp = NULL ;
 static hf_register_info hf [ ] = {
 {
 & hf_mswsp_hdr , {
 "Header" , "mswsp.hdr" , FT_NONE , BASE_NONE , NULL , 0 , "Message header" , HFILL }
 }
 , {
 & hf_mswsp_hdr_msg , {
 "Msg id" , "mswsp.hdr.id" , FT_UINT32 , BASE_HEX , VALS ( msg_ids ) , 0 , "Message id" , HFILL }
 }
 , {
 & hf_mswsp_hdr_status , {
 "Status" , "mswsp.hdr.status" , FT_UINT32 , BASE_HEX , VALS ( dcom_hresult_vals ) , 0 , "Message Status" , HFILL }
 }
 , {
 & hf_mswsp_hdr_checksum , {
 "checksum" , "mswsp.hdr.checksum" , FT_UINT32 , BASE_HEX , NULL , 0 , "Message Checksum" , HFILL }
 }
 , {
 & hf_mswsp_hdr_reserved , {
 "Reserved" , "mswsp.hdr.reserved" , FT_UINT32 , BASE_HEX , NULL , 0 , "Reserved bytes" , HFILL }
 }
 , {
 & hf_mswsp_msg , {
 "msg" , "mswsp.msg" , FT_NONE , BASE_NONE , NULL , 0 , "Message" , HFILL }
 }
 , {
 & hf_mswsp_msg_Connect_Version , {
 "Version" , "mswsp.Connect.version" , FT_UINT32 , BASE_HEX , VALS ( version_vals ) , 0 , "OS Version" , HFILL }
 }
 , {
 & hf_mswsp_msg_ConnectIn_ClientIsRemote , {
 "Remote" , "mswsp.ConnectIn.isRemote" , FT_BOOLEAN , BASE_HEX , NULL , 0 , "Client is remote" , HFILL }
 }
 , {
 & hf_mswsp_msg_ConnectIn_Blob1 , {
 "Size" , "mswsp.ConnectIn.propset.size" , FT_UINT32 , BASE_DEC , NULL , 0 , "Size of PropSet fields" , HFILL }
 }
 , {
 & hf_mswsp_msg_ConnectIn_MachineName , {
 "Remote machine" , "mswsp.ConnectIn.machine" , FT_STRINGZ , BASE_NONE , NULL , 0 , "Name of remote machine" , HFILL }
 }
 , {
 & hf_mswsp_msg_ConnectIn_UserName , {
 "User" , "mswsp.ConnectIn.user" , FT_STRINGZ , BASE_NONE , NULL , 0 , "Name of remote user" , HFILL }
 }
 , {
 & hf_mswsp_msg_ConnectIn_PropSets_num , {
 "Num" , "mswsp.ConnectIn.propset.num" , FT_UINT32 , BASE_DEC , NULL , 0 , "Number of Property Sets" , HFILL }
 }
 , {
 & hf_mswsp_bool_options , {
 "uBooleanOptions" , "mswsp.CPMCreateQuery.RowSetProperties.uBooleanOptions" , FT_UINT32 , BASE_HEX , NULL , 0 , "Boolean options" , HFILL }
 }
 , {
 & hf_mswsp_bool_options_cursor , {
 "Cursor" , "mswsp.CPMCreateQuery.RowSetProperties.uBooleanOptions" , FT_UINT32 , BASE_HEX , VALS ( cursor_vals ) , 0x0000000007 , "Cursor Type" , HFILL }
 }
 , {
 & hf_mswsp_bool_options_async , {
 "eAsynchronous" , "mswsp.CPMCreateQuery.RowSetProperties.uBooleanOptions.eAsyncronous" , FT_BOOLEAN , 32 , NULL , eAsynchronous , "The client will not wait for execution completion" , HFILL }
 }
 , {
 & hf_mswsp_bool_options_firstrows , {
 "eFirstRows" , "mswsp.CPMCreateQuery.RowSetProperties.uBooleanOptions.eFirstRows" , FT_BOOLEAN , 32 , NULL , eFirstRows , "Return the first rows encountered, not the best matches." , HFILL }
 }
 , {
 & hf_mswsp_bool_options_holdrows , {
 "eHoldRows" , "mswsp.CPMCreateQuery.RowSetProperties.uBooleanOptions.eHoldRows" , FT_BOOLEAN , 32 , NULL , eHoldRows , "The server MUST NOT discard rows until the client is done with a query." , HFILL }
 }
 , {
 & hf_mswsp_bool_options_chaptered , {
 "eChaptered" , "mswsp.CPMCreateQuery.RowSetProperties.uBooleanOptions.eChaptered" , FT_BOOLEAN , 32 , NULL , eChaptered , "The rowset supports chapters." , HFILL }
 }
 , {
 & hf_mswsp_bool_options_useci , {
 "eUseCI" , "mswsp.CPMCreateQuery.RowSetProperties.uBooleanOptions.eUseCI" , FT_BOOLEAN , 32 , NULL , eUseCI , "Use the inverted index to evaluate content restrictions even if it is out of date." , HFILL }
 }
 , {
 & hf_mswsp_bool_options_defertrim , {
 "eDeferTrimming" , "mswsp.CPMCreateQuery.RowSetProperties.uBooleanOptions.eDeferTrimming" , FT_BOOLEAN , 32 , NULL , eDeferTrimming , "Defer Non-indexed trimming operations like scoping or security checking which can be expensive." , HFILL }
 }
 , {
 & hf_mswsp_bool_options_rowsetevents , {
 "eEnableRowsetEvents" , "mswsp.RowSetProperties.CPMCreateQuery.uBooleanOptions.eEnableRowsetEvents" , FT_BOOLEAN , 32 , NULL , eEnableRowsetEvents , "Enables storage of rowset events on the server side." , HFILL }
 }
 , {
 & hf_mswsp_bool_options_dontcomputeexpensive , {
 "eDoNotComputeExpensiveProps" , "mswsp.CPMCreateQuery.RowSetProperties.uBooleanOptions.eDoNotComputeExpensiveProps" , FT_BOOLEAN , 32 , NULL , eDoNotComputeExpensiveProps , "Prevents computation of expensive properties." , HFILL }
 }
 , {
 & hf_mswsp_guid_time_low , {
 "time-low" , "mswsp.guid.time_low" , FT_UINT32 , BASE_HEX , NULL , 0 , "time low value" , HFILL }
 }
 , {
 & hf_mswsp_guid_time_mid , {
 "time-mid" , "mswsp.guid.time_mid" , FT_UINT16 , BASE_HEX , NULL , 0 , "time mid value" , HFILL }
 }
 , {
 & hf_mswsp_guid_time_high , {
 "time-high" , "mswsp.guid.time_high" , FT_UINT16 , BASE_HEX , NULL , 0 , "time high value" , HFILL }
 }
 , {
 & hf_mswsp_guid_time_clock_hi , {
 "clock_seq_hi_and_reserved" , "mswsp.guid.time_clock_high" , FT_UINT8 , BASE_HEX , NULL , 0 , "time clock high value" , HFILL }
 }
 , {
 & hf_mswsp_guid_time_clock_low , {
 "clock_seq_low" , "mswsp.guid.time_clock_low" , FT_UINT8 , BASE_HEX , NULL , 0 , "time clock high low" , HFILL }
 }
 , {
 & hf_mswsp_guid_node , {
 "node" , "mswsp.guid.node" , FT_STRING , BASE_NONE , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_lcid , {
 "lcid" , "mswsp.lcid" , FT_UINT32 , BASE_HEX , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_lcid_sortid , {
 "Sort ID" , "mswsp.lcid.sortid" , FT_UINT8 , BASE_HEX , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_lcid_langid , {
 "Language ID" , "mswsp.lcid.langid" , FT_UINT16 , BASE_HEX , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_cscort_column , {
 "column" , "mswsp.csort.column" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_cscort_order , {
 "order" , "mswsp.csort.order" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_cscort_individual , {
 "inidvidual" , "mswsp.csort.individual" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_cscortset_count , {
 "count" , "mswsp.csortset.count" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_ctablecolumn_vtype , {
 "vType" , "mswsp.ctablecolumn.vtype" , FT_STRING , BASE_NONE , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_ctablecolumn_aggused , {
 "AggreagateUsed" , "mswsp.ctablecolumn.aggused" , FT_UINT8 , BASE_HEX , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_ctablecolumn_aggtype , {
 "AggreagateType" , "mswsp.ctablecolumn.aggtype" , FT_STRING , BASE_NONE , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_ctablecolumn_valused , {
 "ValueUsed" , "mswsp.ctablecolumn.valused" , FT_UINT8 , BASE_HEX , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_ctablecolumn_valoffset , {
 "ValueOffset" , "mswsp.ctablecolumn.valused" , FT_UINT16 , BASE_HEX , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_ctablecolumn_valsize , {
 "ValueSize" , "mswsp.ctablecolumn.valsize" , FT_UINT16 , BASE_HEX , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_ctablecolumn_statused , {
 "StatusUsed" , "mswsp.ctablecolumn.statused" , FT_UINT8 , BASE_HEX , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_ctablecolumn_statoffset , {
 "StatusOffset" , "mswsp.ctablecolumn.statoffset" , FT_UINT16 , BASE_HEX , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_ctablecolumn_lenused , {
 "LengthUsed" , "mswsp.ctablecolumn.lenused" , FT_UINT8 , BASE_HEX , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_ctablecolumn_lenoffset , {
 "LengthOffset" , "mswsp.ctablecolumn.lenoffset" , FT_UINT16 , BASE_HEX , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_cfullpropspec_kind , {
 "ulKind" , "mswsp.cfullpropspec.kind" , FT_STRING , BASE_NONE , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_cfullpropspec_propid , {
 "propid" , "mswsp.cfullpropspec.propid" , FT_UINT32 , BASE_HEX , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_cfullpropspec_propname , {
 "propname" , "mswsp.cfullpropspec.propname" , FT_STRING , BASE_NONE , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_cproprestrict_relop , {
 "relop" , "mswsp.cproprestrict.relop" , FT_STRING , BASE_NONE , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_ccoercerestrict_value , {
 "value" , "mswsp.ccoercerestrict.value" , FT_FLOAT , BASE_NONE , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_ccontentrestrict_cc , {
 "cc" , "mswsp.ccontentrestrict.cc" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_ccontentrestrict_phrase , {
 "phrase" , "mswsp.ccontentrestrict.phrase" , FT_STRING , BASE_NONE , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_ccontentrestrict_method , {
 "method" , "mswsp.ccontentrestrict.method" , FT_UINT32 , BASE_HEX , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_natlangrestrict_cc , {
 "cc" , "mswsp.ccontentrestrict.cc" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_natlangrestrict_phrase , {
 "phrase" , "mswsp.ccontentrestrict.phrase" , FT_STRING , BASE_NONE , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_crestrict_ultype , {
 "ulType" , "mswsp.crestrict.ultype" , FT_STRING , BASE_NONE , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_crestrict_weight , {
 "Weight" , "mswsp.crestrict.weight" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_crestrictarray_count , {
 "count" , "mswsp.crestrictarray.count" , FT_UINT8 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_crestrictarray_present , {
 "present" , "mswsp.crestrictarray.present" , FT_UINT8 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_cnoderestrict_cnode , {
 "Weight" , "mswsp.cnoderestrict.cnode" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_cbasestorvariant_vtype , {
 "vType" , "mswsp.cbasestorvariant.vtype" , FT_STRING , BASE_NONE , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_cbasestorvariant_vvalue , {
 "vValue" , "mswsp.cbasestorvariant.vvalue" , FT_STRING , BASE_NONE , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_cbasestorvariant_vdata1 , {
 "vData1" , "mswsp.cbasestorvariant.vdata1" , FT_UINT8 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_cbasestorvariant_vdata2 , {
 "vData2" , "mswsp.cbasestorvariant.vdata2" , FT_UINT8 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_cbasestorvariant_num , {
 "num" , "mswsp.cbasestorvariant.num" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_cbasestorvariant_cdims , {
 "cDims" , "mswsp.cbasestorvariant.cdims" , FT_UINT16 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_cbasestorvariant_ffeatures , {
 "fFeatures" , "mswsp.cbasestorvariant.ffeatures" , FT_UINT16 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_cbasestorvariant_cbelements , {
 "cbElements" , "mswsp.cbasestorvariant.cbelements" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_cbasestorvariant_rgsabound , {
 "Rgsabound" , "mswsp.cbasestorvariant.rgsabound" , FT_STRING , BASE_NONE , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_cdbcolid_ekind , {
 "eKind" , "mswsp.cdbcolid.ekind" , FT_STRING , BASE_NONE , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_cdbcolid_ulid , {
 "ulId" , "mswsp.cdbcolid.ulid" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_cdbcolid_vstring , {
 "vString" , "mswsp.cdbcolid.vstring" , FT_STRING , BASE_NONE , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_cdbprop_id , {
 "Id" , "mswsp.cdbprop.id" , FT_STRING , BASE_NONE , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_cdbprop_options , {
 "Options" , "mswsp.cdbprop.options" , FT_UINT32 , BASE_HEX , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_cdbprop_status , {
 "Status" , "mswsp.cdbprop.status" , FT_UINT32 , BASE_HEX , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_cdbpropset_cprops , {
 "cProperties" , "mswsp.cdbpropset.cprops" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_rangeboundry_ultype , {
 "ulType" , "mswsp.rangeboundry.ultype" , FT_UINT32 , BASE_HEX , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_rangeboundry_labelpresent , {
 "labelPresent" , "mswsp.rangeboundry.labelpresent" , FT_BOOLEAN , 8 , NULL , 0x01 , NULL , HFILL }
 }
 , {
 & hf_mswsp_rangeboundry_cclabel , {
 "ccLabel" , "mswsp.rangeboundry.cclabel" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_rangeboundry_label , {
 "Label" , "mswsp.rangeboundry.label" , FT_STRING , BASE_NONE , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_crangecategspec_crange , {
 "cRange" , "mswsp.crangecategspec.crange" , FT_UINT32 , BASE_HEX , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_ccategspec_type , {
 "type" , "mswsp.ccategspec.type" , FT_UINT8 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_caggregspec_type , {
 "type" , "mswsp.caggregspec.type" , FT_UINT8 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_caggregspec_ccalias , {
 "ccAlias" , "mswsp.caggregspec.ccalias" , FT_UINT8 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_caggregspec_alias , {
 "Alias" , "mswsp.caggregspec.alias" , FT_STRING , BASE_NONE , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_caggregspec_idcolumn , {
 "idColumn" , "mswsp.caggregspec.idcolumn" , FT_UINT8 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_caggregset_count , {
 "count" , "mswsp.caggregset.count" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_caggregsortkey_order , {
 "order" , "mswsp.caggregsortkey.order" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_csortaggregset_count , {
 "count" , "mswsp.csortaggregset.count" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_cingroupsortaggregset_type , {
 "Type" , "mswsp.cingroupsortaggregset.type" , FT_UINT8 , BASE_HEX , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_cingroupsortaggregsets_count , {
 "count" , "mswsp.cingroupsortaggregsets.count" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_categorizationspec_cmaxres , {
 "cMaxResults" , "mswsp.categorizationspec.cmaxres" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_crowsetprops_ulmaxopenrows , {
 "ulMaxOpenRows (ignored)" , "mswsp.crowsetprops.ulmaxopenrows" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_crowsetprops_ulmemusage , {
 "ulMemUsage (ignored)" , "mswsp.crowsetprops.ulmemusage" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_crowsetprops_cmaxresults , {
 "cMaxResults" , "mswsp.crowsetprops.cmaxresults" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_crowsetprops_ccmdtimeout , {
 "cCmdTimeout" , "mswsp.crowsetprops.ccmdtimeout" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_cpidmapper_count , {
 "count" , "mswsp.cpidmapper.count" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_ccolumngroup_count , {
 "count" , "mswsp.ccolumngroup.count" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_ccolumngroup_grouppid , {
 "groupPid" , "mswsp.ccolumngroup.grouppid" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_ccolumngroup_pid , {
 "pid" , "mswsp.ccolumngroup.pid" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_ccolumngrouparray_count , {
 "count" , "mswsp.ccolumngrouparray.count" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_int32array_value , {
 "value" , "mswsp.int32array.value" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_crowseeknext_cskip , {
 "cskip" , "mswsp.crowseeknext.cskip" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_crowseekat_bmkoffset , {
 "bmkoffset" , "mswsp.crowseekat.bmkoffset" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_crowseekat_skip , {
 "skip" , "mswsp.crowseekat.skip" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_crowseekat_hregion , {
 "hregion" , "mswsp.crowseekat.hregion" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_crowseekatratio_ulnumerator , {
 "ulnumerator" , "mswsp.crowseekatratio.ulnumerator" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_crowseekatratio_uldenominator , {
 "uldenominator" , "mswsp.crowseekatratio.uldenominator" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_crowseekatratio_hregion , {
 "hregion" , "mswsp.crowseekatratio.hregion" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_crowseekbybookmark_cbookmarks , {
 "cbookmarks" , "mswsp.crowseekbybookmark.cbookmarks" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_crowseekbybookmark_maxret , {
 "maxret" , "mswsp.crowseekbybookmark.maxret" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_crowvariantinfo_count64 , {
 "count" , "mswsp.crowvariantinfo.count64" , FT_UINT64 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_arrayvector_address64 , {
 "address of array" , "mswsp.arrayvector.address64" , FT_UINT64 , BASE_HEX , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_crowvariantinfo_count32 , {
 "count" , "mswsp.crowvariantinfo.count32" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_arrayvector_address32 , {
 "address of array" , "mswsp.arrayvector.address" , FT_UINT32 , BASE_HEX , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_rowvariant_item_address64 , {
 "address" , "mswsp.rowvariant.item.address64" , FT_UINT64 , BASE_HEX , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_rowvariant_item_address32 , {
 "address" , "mswsp.rowvariant.item.address32" , FT_UINT32 , BASE_HEX , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_rowvariant_item_value , {
 "value" , "mswsp.rowvariant.item.value" , FT_STRING , BASE_NONE , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_rowvariant_vtype , {
 "vtype" , "mswsp.rowvariant.vtype" , FT_STRING , BASE_NONE , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_rowvariant_reserved1 , {
 "reserved1" , "mswsp.rowvariant.reserved1" , FT_UINT16 , BASE_HEX , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_rowvariant_reserved2 , {
 "reserved2" , "mswsp.rowvariant.reserved2" , FT_UINT32 , BASE_HEX , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_ctablecolumn_status , {
 "status" , "mswsp.ctablecolumn.name" , FT_STRING , BASE_NONE , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_ctablecolumn_length , {
 "length" , "mswsp.ctablecolumn.length" , FT_UINT8 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmcreatequery_size , {
 "size" , "mswsp.cpmcreatequery.size" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmcreatequery_ccolumnsetpresent , {
 "CColumnSetPresent" , "mswsp.cpmcreatequery.ccolumnsetpresent" , FT_BOOLEAN , 8 , NULL , 0x01 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmcreatequery_crestrictionpresent , {
 "CRestrictionPresent" , "mswsp.cpmcreatequery.crestrictionpresent" , FT_BOOLEAN , 8 , NULL , 0x01 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmcreatequery_csortpresent , {
 "CSortPresent" , "mswsp.cpmcreatequery.csortpresent" , FT_BOOLEAN , 8 , NULL , 0x01 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmcreatequery_ccategpresent , {
 "CCategorizationSetPresent" , "mswsp.cpmcreatequery.ccategpresent" , FT_BOOLEAN , 8 , NULL , 0x01 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmcreatequery_ccateg_count , {
 "count" , "mswsp.cpmcreatequery.ccateg.count" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmcreatequery_trueseq , {
 "TrueSequential" , "mswsp.cpmcreatequery.trueseq" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmcreatequery_workid , {
 "WorkId" , "mswsp.cpmcreatequery.trueseq" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmcreatequery_cursors , {
 "Cursors" , "mswsp.cpmcreatequery.cursors" , FT_BYTES , SEP_SPACE , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmgetrows_hcursor , {
 "hCursor" , "mswsp.msg.cpmgetrows.hcursor" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmgetrows_rowstotransfer , {
 "cRowsToTransfer" , "mswsp.msg.cpmgetrows.rowstotransfer" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmgetrows_rowwidth , {
 "cbRowWidth" , "mswsp.msg.cpmgetrows.rowswidth" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmgetrows_cbseek , {
 "cbSeek" , "mswsp.msg.cpmgetrows.cbseek" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmgetrows_cbreserved , {
 "cbReserved" , "mswsp.msg.cpmgetrows.cbreserved" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmgetrows_cbreadbuffer , {
 "cbReadBuffer" , "mswsp.msg.cpmgetrows.cbreadbuffer" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmgetrows_ulclientbase , {
 "ulClientBase" , "mswsp.msg.cpmgetrows.ulclientbase" , FT_UINT32 , BASE_HEX , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmgetrows_fbwdfetch , {
 "fBwdFetch" , "mswsp.msg.cpmgetrows.fbwdfetch" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmgetrows_etype , {
 "eType" , "mswsp.msg.cpmgetrows.etype" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmgetrows_chapt , {
 "chapt" , "mswsp.msg.cpmgetrows.chapt" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmgetrows_crowsreturned , {
 "cRowsReturned" , "mswsp.msg.cpmgetrows.crowsreturned" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmratiofinished_hcursor , {
 "hCursor" , "mswsp.msg.cpmratiofinished_hcursor" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmratiofinished_fquick , {
 "fQuick" , "mswsp.msg.cpmratiofinished_fquick" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmratiofinished_ulnumerator , {
 "ulNumerator" , "mswsp.msg.cpmratiofinished_ulnumerator" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmratiofinished_uldenominator , {
 "ulDenominator" , "mswsp.msg.cpmratiofinished_uldenominator" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmratiofinished_crows , {
 "cRows" , "mswsp.msg.cpmratiofinished_crows" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmratiofinished_fnewrows , {
 "fNewRows" , "mswsp.msg.cpmratiofinished_fnewrows" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmcomparebmk_hcursor , {
 "hCursor" , "mswsp.msg.cpmcomparebmk.hcursor" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmcomparebmk_chapt , {
 "chapt" , "mswsp.msg.cpmcomparebmk.chapt" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmcomparebmk_bmkfirst , {
 "bmkFirst" , "mswsp.msg.cpmcomparebmk.bmkfirst" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmcomparebmk_bmksecond , {
 "bmkSecond" , "mswsp.msg.cpmcomparebmk.bmksecond" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmcomparebmk_dwcomparison , {
 "dwComparison" , "mswsp.msg.cpmcomparebmk.dwcomparison" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmgetapproxpos_hcursor , {
 "hCursor" , "mswsp.msg.cpmgetapproxpos.hcursor" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmgetapproxpos_chapt , {
 "chapt" , "mswsp.msg.cpmgetapproxpos.chapt" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmgetapproxpos_bmk , {
 "bmk" , "mswsp.msg.cpmgetapproxpos.bmk" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmgetapproxpos_numerator , {
 "numerator" , "mswsp.msg.cpmgetapproxpos.numerator" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmgetapproxpos_denominator , {
 "denominator" , "mswsp.msg.cpmgetapproxpos.denominator" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmsetbinding_hcursor , {
 "hCursor" , "mswsp.msg.cpmsetbinding.hcursor" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmsetbinding_cbrow , {
 "cBrow" , "mswsp.msg.cpmsetbinding.cbrow" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmsetbinding_desc , {
 "cbBindingDesc" , "mswsp.msg.cpmsetbinding.desc" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmsetbinding_dummy , {
 "dummy" , "mswsp.msg.cpmsetbinding.dummy" , FT_UINT32 , BASE_HEX , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmsetbinding_ccolumns , {
 "cColumns" , "mswsp.msg.cpmsetbinding.ccolumns" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmsetbinding_acolumns , {
 "aColumns" , "mswsp.msg.cpmsetbinding.acolumns" , FT_BYTES , SEP_DOT , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmsendnotify_watchnotify , {
 "watchNotify" , "mswsp.msg.cpmsendnotify.watchnotify" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmgetquerystatus_hcursor , {
 "hCursor" , "mswsp.msg.cpmquerystatus.hcursor" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmgetquerystatus_qstatus , {
 "QStatus" , "mswsp.msg.cpmquerystatus.qstatus" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmcistate_cbstruct , {
 "cbStruct" , "mswsp.msg.cpmcistate.cbstruct" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmcistate_cwordlist , {
 "cbWordList" , "mswsp.msg.cpmcistate.cbwordlist" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmcistate_cpersistindex , {
 "cbPersistentIndex" , "mswsp.msg.cpmcistate.cbpersistindex" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmcistate_cqueries , {
 "cQueries" , "mswsp.msg.cpmcistate.cqueries" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmcistate_cfreshtest , {
 "cFreshTest" , "mswsp.msg.cpmcistate.cfreshtest" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmcistate_dwmergeprogress , {
 "dwMergeProgress" , "mswsp.msg.cpmcistate.dwmergeprogress" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmcistate_estate , {
 "eState" , "mswsp.msg.cpmcistate.estate" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmcistate_cfiltereddocs , {
 "cFilteredDocuments" , "mswsp.msg.cpmcistate.cfiltereddocs" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmcistate_ctotaldocs , {
 "cTotalDocuments" , "mswsp.msg.cpmcistate.ctotaldocs" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmcistate_cpendingscans , {
 "cPendingScans" , "mswsp.msg.cpmcistate.cpendingscans" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmcistate_dwindexsize , {
 "dwIndexSize" , "mswsp.msg.cpmcistate.dwindexsize" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmcistate_cuniquekeys , {
 "cUniqueKeys" , "mswsp.msg.cpmcistate.cuniquekeys" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmcistate_csecqdocuments , {
 "cSecQDocuments" , "mswsp.msg.cpmcistate.csecqdocuments" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmcistate_dwpropcachesize , {
 "dwPropCacheSize" , "mswsp.msg.cpmcistate.dwpropcachesize" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmfetchvalue_wid , {
 "wid" , "mswsp.msg.cpmfetchvalue.wid" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmfetchvalue_cbsofar , {
 "cbSoFar" , "mswsp.msg.cpmfetchvalue.cbsofar" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmfetchvalue_cbpropspec , {
 "cbPropSpec" , "mswsp.msg.cpmfetchvalue.cbpropspec" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmfetchvalue_cbchunk , {
 "cbChunk" , "mswsp.msg.cpmfetchvalue.chunk" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmfetchvalue_cbvalue , {
 "cbValue" , "mswsp.msg.cpmfetchvalue.cbvalue" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmfetchvalue_fmoreexists , {
 "fMoreExists" , "mswsp.msg.cpmfetchvalue.fmoreexists" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmfetchvalue_fvalueexists , {
 "fValueExists" , "mswsp.msg.cpmfetchvalue.fvalueexists" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmfetchvalue_vvalue , {
 "vvalue" , "mswsp.msg.cpmfetchvalue.vvalue" , FT_BYTES , SEP_SPACE , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmquerystatusex_qstatus , {
 "qStatus" , "mswsp.msg.cpmquerystatusex.qstatus" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmquerystatusex_hcursor , {
 "hCursor" , "mswsp.msg.cpmquerystatusex.hcursor" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmquerystatusex_bmk , {
 "bmk" , "mswsp.msg.cpmquerystatusex.bmk" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmquerystatusex_cfiltereddocs , {
 "cFilteredDocuments" , "mswsp.msg.cpmquerystatusex.cfiltereddocs" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmquerystatusex_cdocstofilter , {
 "cDocumentsToFilter" , "mswsp.msg.cpmquerystatusex.cdocstofilter" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmquerystatusex_dwratiodenom , {
 "dwRatioFinishedDenomenator" , "mswsp.msg.cpmquerystatusex.dwratiodenom" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmquerystatusex_dwrationumer , {
 "dwRatioFinishedNumerator" , "mswsp.msg.cpmquerystatusex.dwrationumer" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmquerystatusex_irowbmk , {
 "iRowBmk" , "mswsp.msg.cpmquerystatusex.irowbmk" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmquerystatusex_crowstotal , {
 "cRowsTotal" , "mswsp.msg.cpmquerystatusex.crowstotal" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmquerystatusex_maxrank , {
 "maxRank" , "mswsp.msg.cpmquerystatusex.maxrank" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmquerystatusex_cresultsfound , {
 "cResultsFound" , "mswsp.msg.cpmquerystatusex.cresultsfound" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmquerystatusex_whereid , {
 "whereId" , "mswsp.msg.cpmquerystatusex.whereid" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmrestartposition_hcursor , {
 "hCursor" , "mswsp.msg.cpmrestartposition.hcursor" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmrestartposition_chapt , {
 "chapt" , "mswsp.msg.cpmrestartposition.chapt" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmgetrowsetnotify_wid , {
 "wid" , "mswsp.msg.cpmgetrowsetnotify.wid" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmgetrowsetnotify_moreevents , {
 "moreEvents" , "mswsp.msg.cpmgetrowsetnotify.moreevents" , FT_BOOLEAN , 8 , NULL , 0x01 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmgetrowsetnotify_eventtype , {
 "eventType" , "mswsp.msg.cpmgetrowsetnotify.eventType" , FT_UINT8 , BASE_DEC , NULL , 0xFE , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmgetrowsetnotify_rowsetitemstate , {
 "rowSetItemState" , "mswsp.msg.cpmgetrowsetnotify.rowsetitemstate" , FT_UINT8 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmgetrowsetnotify_changeditemstate , {
 "changedItemState" , "mswsp.msg.cpmgetrowsetnotify.changeditemState" , FT_UINT8 , BASE_DEC , NULL , 0 , 0 , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmgetrowsetnotify_rowsetevent , {
 "rowSetEvent" , "mswsp.msg.cpmgetrowsetnotify.rowsetevent" , FT_UINT8 , BASE_DEC , NULL , 0 , 0 , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmgetrowsetnotify_rowseteventdata1 , {
 "rowSetEventdata1" , "mswsp.msg.cpmgetrowsetnotify.rowseteventdata1" , FT_UINT64 , BASE_HEX , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmgetrowsetnotify_rowseteventdata2 , {
 "rowSetEventdata2" , "mswsp.msg.cpmgetrowsetnotify.rowseteventdata2" , FT_UINT64 , BASE_HEX , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmfindindices_cwids , {
 "cWids" , "mswsp.msg.cpmfindindices.cwids" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmfindindices_cdepthprev , {
 "cDepthPrev" , "mswsp.msg.cpmfindindices.cdepthprev" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmfindindices_cdepthnext , {
 "cDepthNext" , "mswsp.msg.cpmfindindices.cdepthnext" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmsetscopeprioritization_priority , {
 "priority" , "mswsp.msg.cpmsetscopeprioritization.priority" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmsetscopeprioritization_eventfreq , {
 "eventFrequency" , "mswsp.msg.cpmsetscopeprioritization.eventfreq" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmsetscopestatisics_dwindexitems , {
 "dwIndexedItems" , "mswsp.msg.cpmsetscopestatistics.dwindexitems" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmsetscopestatisics_dwoutstandingadds , {
 "dwOutstandingAdds" , "mswsp.msg.cpmsetscopestatistics.dwoutstandingadds" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 , {
 & hf_mswsp_msg_cpmsetscopestatisics_dwoutstandingmodifies , {
 "dwOutstandingModifies" , "mswsp.msg.cpmsetscopestatistics.dwoutstandingmodifies" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
 }
 }
 ;
 static gint * ett [ ] = {
 & ett_mswsp , & ett_mswsp_hdr , & ett_mswsp_msg , & ett_mswsp_pad , & ett_mswsp_property_restriction , & ett_CRestrictionArray , & ett_CBaseStorageVariant , & ett_CBaseStorageVariant_Vector , & ett_CBaseStorageVariant_Array , & ett_CDbColId , & ett_GUID , & ett_CDbProp , & ett_CDbPropSet , & ett_CDbPropSet_Array , & ett_CRestriction , & ett_CNodeRestriction , & ett_CPropertyRestriction , & ett_CCoercionRestriction , & ett_CContentRestriction , & ett_RANGEBOUNDARY , & ett_CRangeCategSpec , & ett_CCategSpec , & ett_CAggregSpec , & ett_CAggregSet , & ett_CCategorizationSpec , & ett_CAggregSortKey , & ett_CSortAggregSet , & ett_CInGroupSortAggregSet , & ett_CInGroupSortAggregSets , & ett_CRowsetProperties , & ett_CFullPropSpec , & ett_CPidMapper , & ett_CSort , & ett_CSortSet , & ett_CNatLanguageRestriction , & ett_CColumnGroup , & ett_CColumnGroupArray , & ett_LCID , & ett_CTableColumn , & ett_Array , & ett_SeekDescription , & ett_CRowsSeekNext , & ett_CRowsSeekAt , & ett_CRowsSeekAtRatio , & ett_CRowsSeekByBookmark , & ett_GetRowsRow , & ett_GetRowsColumn , & ett_CRowVariant , & ett_CRowVariant_Vector , & ett_mswsp_bool_options , & ett_mswsp_uin32_array , & ett_mswsp_msg_padding , & ett_mswsp_msg_creusewhere }
 ;
 static ei_register_info ei [ ] = {
 {
 & ei_mswsp_invalid_variant_type , {
 "mswsp.invalid_variant_type" , PI_PROTOCOL , PI_ERROR , "Invalid variant type" , EXPFILL }
 }
 , {
 & ei_missing_msg_context , {
 "mswsp.msg.cpmgetrows.missing_msg_context" , PI_SEQUENCE , PI_WARN , "previous messages needed for context not captured" , EXPFILL }
 }
 , {
 & ei_mswsp_msg_cpmsetbinding_ccolumns , {
 "mswsp.msg.cpmsetbinding.ccolumns.invalude" , PI_PROTOCOL , PI_WARN , "Invalid number of cColumns for packet" , EXPFILL }
 }
 }
 ;
 int i ;
 proto_mswsp = proto_register_protocol ( "Windows Search Protocol" , "MS-WSP" , "mswsp" ) ;
 proto_register_field_array ( proto_mswsp , hf , array_length ( hf ) ) ;
 proto_register_subtree_array ( ett , array_length ( ett ) ) ;
 expert_mswsp = expert_register_protocol ( proto_mswsp ) ;
 expert_register_field_array ( expert_mswsp , ei , array_length ( ei ) ) ;
 for ( i = 0 ;
 i < ( int ) array_length ( GuidPropertySet ) ;
 i ++ ) {
 guids_add_guid ( & GuidPropertySet [ i ] . guid , GuidPropertySet [ i ] . def ) ;
 }
 }


bool SendWaitForAllTabsToStopLoadingJSONRequest(
    AutomationMessageSender* sender,
    std::string* error_msg) {
  DictionaryValue dict;
  dict.SetString("command", "WaitForAllTabsToStopLoading");
  DictionaryValue reply_dict;
  return SendAutomationJSONRequest(sender, dict, &reply_dict, error_msg);
}


bool FrameLoader::isReplacing() const
{
    return m_loadType == FrameLoadTypeReplace;
}


create_iovec(QEMUIOVector *qiov, char **argv, int nr_iov, int pattern)

{

	size_t *sizes = calloc(nr_iov, sizeof(size_t));

	size_t count = 0;

	void *buf, *p;

	int i;

	for (i = 0; i < nr_iov; i++) {

		char *arg = argv[i];

		long long len;

		len = cvtnum(arg);

		if (len < 0) {

			printf("non-numeric length argument -- %s\n", arg);

			return NULL;

		}

		/* should be SIZE_T_MAX, but that doesn't exist */

		if (len > UINT_MAX) {

			printf("too large length argument -- %s\n", arg);

			return NULL;

		}

		if (len & 0x1ff) {

			printf("length argument %lld is not sector aligned\n",

				len);

			return NULL;

		}

		sizes[i] = len;

		count += len;

	}

	qemu_iovec_init(qiov, nr_iov);

	buf = p = qemu_io_alloc(count, pattern);

	for (i = 0; i < nr_iov; i++) {

		qemu_iovec_add(qiov, p, sizes[i]);

		p += sizes[i];

	}

	free(sizes);

	return buf;

}


int virtio_queue_get_id(VirtQueue *vq)
{
    VirtIODevice *vdev = vq->vdev;
    assert(vq >= &vdev->vq[0] && vq < &vdev->vq[VIRTIO_PCI_QUEUE_MAX]);
    return vq - &vdev->vq[0];
}


void comps_objrtree_destroy_u(COMPS_Object *obj) {
    comps_objrtree_destroy((COMPS_ObjRTree*)obj);
}


static inline void timer_base_unlock_expiry(struct timer_base *base)
{
	spin_unlock(&base->expiry_lock);
}


void ConnPoolImplBase::onConnectionEvent(ActiveClient& client, absl::string_view failure_reason,
                                         Network::ConnectionEvent event) {
  if (client.state() == ActiveClient::State::CONNECTING) {
    ASSERT(connecting_stream_capacity_ >= client.effectiveConcurrentStreamLimit());
    connecting_stream_capacity_ -= client.effectiveConcurrentStreamLimit();
  }

  if (client.connect_timer_) {
    client.connect_timer_->disableTimer();
    client.connect_timer_.reset();
  }

  if (event == Network::ConnectionEvent::RemoteClose ||
      event == Network::ConnectionEvent::LocalClose) {
    state_.decrConnectingAndConnectedStreamCapacity(client.currentUnusedCapacity());
    // Make sure that onStreamClosed won't double count.
    client.remaining_streams_ = 0;
    // The client died.
    ENVOY_CONN_LOG(debug, "client disconnected, failure reason: {}", client, failure_reason);

    Envoy::Upstream::reportUpstreamCxDestroy(host_, event);
    const bool incomplete_stream = client.closingWithIncompleteStream();
    if (incomplete_stream) {
      Envoy::Upstream::reportUpstreamCxDestroyActiveRequest(host_, event);
    }

    if (client.state() == ActiveClient::State::CONNECTING) {
      host_->cluster().stats().upstream_cx_connect_fail_.inc();
      host_->stats().cx_connect_fail_.inc();

      ConnectionPool::PoolFailureReason reason;
      if (client.timed_out_) {
        reason = ConnectionPool::PoolFailureReason::Timeout;
      } else if (event == Network::ConnectionEvent::RemoteClose) {
        reason = ConnectionPool::PoolFailureReason::RemoteConnectionFailure;
      } else {
        reason = ConnectionPool::PoolFailureReason::LocalConnectionFailure;
      }

      // Raw connect failures should never happen under normal circumstances. If we have an upstream
      // that is behaving badly, streams can get stuck here in the pending state. If we see a
      // connect failure, we purge all pending streams so that calling code can determine what to
      // do with the stream.
      // NOTE: We move the existing pending streams to a temporary list. This is done so that
      //       if retry logic submits a new stream to the pool, we don't fail it inline.
      purgePendingStreams(client.real_host_description_, failure_reason, reason);
      // See if we should preconnect based on active connections.
      if (!is_draining_for_deletion_) {
        tryCreateNewConnections();
      }
    }

    // We need to release our resourceManager() resources before checking below for
    // whether we can create a new connection. Normally this would happen when
    // client's destructor runs, but this object needs to be deferredDelete'd(), so
    // this forces part of its cleanup to happen now.
    client.releaseResources();

    // Again, since we know this object is going to be deferredDelete'd(), we take
    // this opportunity to disable and reset the connection duration timer so that
    // it doesn't trigger while on the deferred delete list. In theory it is safe
    // to handle the CLOSED state in onConnectionDurationTimeout, but we handle
    // it here for simplicity and safety anyway.
    if (client.connection_duration_timer_) {
      client.connection_duration_timer_->disableTimer();
      client.connection_duration_timer_.reset();
    }

    dispatcher_.deferredDelete(client.removeFromList(owningList(client.state())));

    // Check if the pool transitioned to idle state after removing closed client
    // from one of the client tracking lists.
    // There is no need to check if other connections are idle in a draining pool
    // because the pool will close all idle connection when it is starting to
    // drain.
    // Trying to close other connections here can lead to deep recursion when
    // a large number idle connections are closed at the start of pool drain.
    // See CdsIntegrationTest.CdsClusterDownWithLotsOfIdleConnections for an example.
    checkForIdleAndNotify();

    client.setState(ActiveClient::State::CLOSED);

    // If we have pending streams and we just lost a connection we should make a new one.
    if (!pending_streams_.empty()) {
      tryCreateNewConnections();
    }
  } else if (event == Network::ConnectionEvent::Connected) {
    client.conn_connect_ms_->complete();
    client.conn_connect_ms_.reset();
    ASSERT(client.state() == ActiveClient::State::CONNECTING);
    bool streams_available = client.currentUnusedCapacity() > 0;
    transitionActiveClientState(client, streams_available ? ActiveClient::State::READY
                                                          : ActiveClient::State::BUSY);

    // Now that the active client is ready, set up a timer for max connection duration.
    const absl::optional<std::chrono::milliseconds> max_connection_duration =
        client.parent_.host()->cluster().maxConnectionDuration();
    if (max_connection_duration.has_value()) {
      client.connection_duration_timer_ = client.parent_.dispatcher().createTimer(
          [&client]() { client.onConnectionDurationTimeout(); });
      client.connection_duration_timer_->enableTimer(max_connection_duration.value());
    }

    // At this point, for the mixed ALPN pool, the client may be deleted. Do not
    // refer to client after this point.
    onConnected(client);
    if (streams_available) {
      onUpstreamReady();
    }
    checkForIdleAndCloseIdleConnsIfDraining();
  }
}


static int isoent_rr_move ( struct archive_write * a ) {
 struct iso9660 * iso9660 = a -> format_data ;
 struct path_table * pt ;
 struct isoent * rootent , * rr_moved ;
 struct isoent * np , * last ;
 int r ;
 pt = & ( iso9660 -> primary . pathtbl [ MAX_DEPTH - 1 ] ) ;
 if ( pt -> cnt == 0 ) return ( ARCHIVE_OK ) ;
 rootent = iso9660 -> primary . rootent ;
 rr_moved = isoent_find_child ( rootent , "rr_moved" ) ;
 if ( rr_moved != NULL && rr_moved != rootent -> children . first ) {
 isoent_remove_child ( rootent , rr_moved ) ;
 isoent_add_child_head ( rootent , rr_moved ) ;
 }
 np = pt -> first ;
 while ( np != NULL ) {
 last = path_table_last_entry ( pt ) ;
 for ( ;
 np != NULL ;
 np = np -> ptnext ) {
 struct isoent * mvent ;
 struct isoent * newent ;
 if ( ! np -> dir ) continue ;
 for ( mvent = np -> subdirs . first ;
 mvent != NULL ;
 mvent = mvent -> drnext ) {
 r = isoent_rr_move_dir ( a , & rr_moved , mvent , & newent ) ;
 if ( r < 0 ) return ( r ) ;
 isoent_collect_dirs ( & ( iso9660 -> primary ) , newent , 2 ) ;
 }
 }
 np = last -> ptnext ;
 }
 return ( ARCHIVE_OK ) ;
 }


NativePanel* Panel::CreateNativePanel(Browser* browser, Panel* panel,
                                      const gfx::Rect& bounds) {
  PanelBrowserView* view = new PanelBrowserView(browser, panel, bounds);
  (new BrowserFrame(view))->InitBrowserFrame();
  return view;
}


client_close_proxy(struct archive_read_filter *self)
{
	int r = ARCHIVE_OK, r2;
	unsigned int i;

	if (self->archive->client.closer == NULL)
		return (r);
	for (i = 0; i < self->archive->client.nodes; i++)
	{
		r2 = (self->archive->client.closer)
			((struct archive *)self->archive,
				self->archive->client.dataset[i].data);
		if (r > r2)
			r = r2;
	}
	return (r);
}


void Location::assign(LocalDOMWindow* current_window,
                      LocalDOMWindow* entered_window,
                      const USVStringOrTrustedURL& stringOrUrl,
                      ExceptionState& exception_state) {
  if (!BindingSecurity::ShouldAllowAccessTo(current_window, this,
                                            exception_state)) {
    return;
  }

  String url = GetStringFromTrustedURL(stringOrUrl, current_window->document(),
                                       exception_state);
  if (!exception_state.HadException()) {
    SetLocation(url, current_window, entered_window, &exception_state);
  }
}


static Jsi_OpCodes *code_shf(int right) { JSI_NEW_CODES(0,OP_SHF, right); }


SampleTable::~SampleTable() {
 delete[] mSampleToChunkEntries;
    mSampleToChunkEntries = NULL;

 delete[] mSyncSamples;
    mSyncSamples = NULL;

 delete mCompositionDeltaLookup;
    mCompositionDeltaLookup = NULL;

 delete[] mCompositionTimeDeltaEntries;
    mCompositionTimeDeltaEntries = NULL;

 delete[] mSampleTimeEntries;
    mSampleTimeEntries = NULL;

 delete mSampleIterator;
    mSampleIterator = NULL;
}


    void processSourceAttribute(const NameType& attributeName, const String& attributeValue)
    {
        if (match(attributeName, srcsetAttr) && m_srcsetImageCandidate.isEmpty()) {
            m_srcsetAttributeValue = attributeValue;
            m_srcsetImageCandidate = bestFitSourceForSrcsetAttribute(m_mediaValues->devicePixelRatio(), m_sourceSize, attributeValue);
        } else if (match(attributeName, sizesAttr) && !m_sourceSizeSet) {
            m_sourceSize = SizesAttributeParser(m_mediaValues, attributeValue).length();
            m_sourceSizeSet = true;
            if (!m_srcsetImageCandidate.isEmpty()) {
                m_srcsetImageCandidate = bestFitSourceForSrcsetAttribute(m_mediaValues->devicePixelRatio(), m_sourceSize, m_srcsetAttributeValue);
            }
        } else if (match(attributeName, mediaAttr)) {
            m_matchedMediaAttribute = mediaAttributeMatches(*m_mediaValues, attributeValue);
        }
    }


dyn_destroy_function(struct CRYPTO_dynlock_value *l, const char *file, int line)
{
	MUTEX_FREE(l->mutex);
	free(l);
}


bool Smb4KGlobal::addShare(Smb4KShare *share)
{
  Q_ASSERT(share);

  bool added = false;

  if (share)
  {
    mutex.lock();

    if (!findShare(share->unc(), share->workgroupName()))
    {
      p->sharesList.append(share);
      added = true;
    }
    else
    {
    }
  }
  else
  {
  }

  mutex.unlock();

  return added;
}


void gdev_x_clear_window ( gx_device_X * xdev ) {
 if ( ! xdev -> ghostview ) {
 if ( xdev -> useBackingPixmap ) {
 if ( xdev -> bpixmap == 0 ) {
 x_error_handler . oldhandler = XSetErrorHandler ( x_catch_alloc ) ;
 x_error_handler . alloc_error = False ;
 xdev -> bpixmap = XCreatePixmap ( xdev -> dpy , xdev -> win , xdev -> width , xdev -> height , xdev -> vinfo -> depth ) ;
 XSync ( xdev -> dpy , False ) ;
 if ( x_error_handler . alloc_error ) {
 xdev -> useBackingPixmap = False ;
 # ifdef DEBUG emprintf ( xdev -> memory , "Warning: Failed to allocated backing pixmap.\n" ) ;
 # endif if ( xdev -> bpixmap ) {
 XFreePixmap ( xdev -> dpy , xdev -> bpixmap ) ;
 xdev -> bpixmap = None ;
 XSync ( xdev -> dpy , False ) ;
 }
 }
 x_error_handler . oldhandler = XSetErrorHandler ( x_error_handler . oldhandler ) ;
 }
 }
 else {
 if ( xdev -> bpixmap != 0 ) {
 XFreePixmap ( xdev -> dpy , xdev -> bpixmap ) ;
 xdev -> bpixmap = ( Pixmap ) 0 ;
 }
 }
 }
 x_set_buffer ( xdev ) ;
 if ( xdev -> dest == ( Pixmap ) 0 ) {
 xdev -> dest = ( xdev -> bpixmap != ( Pixmap ) 0 ? xdev -> bpixmap : ( Pixmap ) xdev -> win ) ;
 }
 if ( xdev -> dest != ( Pixmap ) 0 ) {
 XSetForeground ( xdev -> dpy , xdev -> gc , xdev -> background ) ;
 XFillRectangle ( xdev -> dpy , xdev -> dest , xdev -> gc , 0 , 0 , xdev -> width , xdev -> height ) ;
 }
 if ( xdev -> bpixmap != ( Pixmap ) 0 ) {
 if ( ! xdev -> ghostview ) XSetWindowBackgroundPixmap ( xdev -> dpy , xdev -> win , xdev -> bpixmap ) ;
 XSetForeground ( xdev -> dpy , xdev -> gc , xdev -> background ) ;
 XFillRectangle ( xdev -> dpy , xdev -> bpixmap , xdev -> gc , 0 , 0 , xdev -> width , xdev -> height ) ;
 }
 xdev -> back_color = xdev -> background ;
 XSetBackground ( xdev -> dpy , xdev -> gc , xdev -> background ) ;
 xdev -> fore_color = xdev -> background ;
 XSetForeground ( xdev -> dpy , xdev -> gc , xdev -> background ) ;
 xdev -> colors_or = xdev -> colors_and = xdev -> background ;
 }


static inline int __br_ip6_hash(struct net_bridge_mdb_htable *mdb,
				const struct in6_addr *ip)
{
	return jhash2((__force u32 *)ip->s6_addr32, 4, mdb->secret) & (mdb->max - 1);
}


static void add_gatt_uuid(struct gatt_db_attribute *attrib, void *user_data)
{
	GHashTable *uuids = user_data;
	bt_uuid_t uuid, u128;
	char uuidstr[MAX_LEN_UUID_STR + 1];

	if (!gatt_db_service_get_active(attrib))
		return;

	if (!gatt_db_attribute_get_service_uuid(attrib, &uuid))
		return;

	bt_uuid_to_uuid128(&uuid, &u128);
	bt_uuid_to_string(&u128, uuidstr, sizeof(uuidstr));

	g_hash_table_add(uuids, strdup(uuidstr));
}


GF_Err gf_isom_clone_pl_indications(GF_ISOFile *orig, GF_ISOFile *dest)
{
	GF_IsomInitialObjectDescriptor *iod_d;
	if (!orig || !dest) return GF_BAD_PARAM;
	if (!orig->moov->iods || !orig->moov->iods->descriptor) return GF_OK;
	if (orig->moov->iods->descriptor->tag != GF_ODF_ISOM_IOD_TAG) return GF_OK;

	AddMovieIOD(dest->moov, 1);
	gf_odf_desc_del((GF_Descriptor *)dest->moov->iods->descriptor);
	gf_odf_desc_copy((GF_Descriptor *)orig->moov->iods->descriptor, (GF_Descriptor **)&dest->moov->iods->descriptor);
	iod_d = (GF_IsomInitialObjectDescriptor *) dest->moov->iods->descriptor;
	while (gf_list_count(iod_d->ES_ID_IncDescriptors)) {
		GF_Descriptor *d = (GF_Descriptor *)gf_list_get(iod_d->ES_ID_IncDescriptors, 0);
		gf_list_rem(iod_d->ES_ID_IncDescriptors, 0);
		gf_odf_desc_del(d);
	}
	while (gf_list_count(iod_d->ES_ID_RefDescriptors)) {
		GF_Descriptor *d = (GF_Descriptor *)gf_list_get(iod_d->ES_ID_RefDescriptors, 0);
		gf_list_rem(iod_d->ES_ID_RefDescriptors, 0);
		gf_odf_desc_del(d);
	}
	return GF_OK;
}


HRESULT CGaiaCredentialBase::SetComboBoxSelectedValue(DWORD field_id,
                                                      DWORD dwSelectedItem) {
  return E_NOTIMPL;
}


void BaseMultipleFieldsDateAndTimeInputType::updateClearButtonVisibility()
{
    ClearButtonElement* clearButton = clearButtonElement();
    if (!clearButton)
        return;

    if (element()->isRequired() || !dateTimeEditElement()->anyEditableFieldsHaveValues())
        clearButton->setInlineStyleProperty(CSSPropertyVisibility, CSSValueHidden);
    else
        clearButton->removeInlineStyleProperty(CSSPropertyVisibility);
}


static void *tcp_v6_tw_get_peer(struct sock *sk)
{
	struct inet6_timewait_sock *tw6 = inet6_twsk(sk);
	struct inet_timewait_sock *tw = inet_twsk(sk);

	if (tw->tw_family == AF_INET)
		return tcp_v4_tw_get_peer(sk);

	return inet_getpeer_v6(&tw6->tw_v6_daddr, 1);
}


command_send_text (Fep *fep,
		   FepControlMessage *request)
{
  _fep_output_send_text (fep, request->args[0].str);
}


static void * writer_child_next ( void * obj , void * prev ) {
 WriterContext * ctx = obj ;
 if ( ! prev && ctx -> writer && ctx -> writer -> priv_class && ctx -> priv ) return ctx -> priv ;
 return NULL ;
 }


ZEND_API zval *zend_ts_hash_str_find(TsHashTable *ht, const char *key, size_t len)
{
	zval *retval;

	begin_read(ht);
	retval = zend_hash_str_find(TS_HASH(ht), key, len);
	end_read(ht);

	return retval;
}


qemuProcessQMPNew(const char *binary,
                  const char *libDir,
                  uid_t runUid,
                  gid_t runGid,
                  bool forceTCG)
{
    g_autoptr(qemuProcessQMP) proc = NULL;
    const char *threadSuffix;
    g_autofree char *threadName = NULL;

    VIR_DEBUG("exec=%s, libDir=%s, runUid=%u, runGid=%u, forceTCG=%d",
              binary, libDir, runUid, runGid, forceTCG);

    proc = g_new0(qemuProcessQMP, 1);

    proc->binary = g_strdup(binary);
    proc->libDir = g_strdup(libDir);

    proc->runUid = runUid;
    proc->runGid = runGid;
    proc->forceTCG = forceTCG;

    threadSuffix = strrchr(binary, '-');
    if (threadSuffix)
        threadSuffix++;
    else
        threadSuffix = binary;
    threadName = g_strdup_printf("qmp-%s", threadSuffix);

    if (!(proc->eventThread = virEventThreadNew(threadName)))
        return NULL;

    return g_steal_pointer(&proc);
}


void CLASS parse_broadcom () {

/* This structure is at offset 0xb0 from the 'BRCM' ident. */
  struct {
    uint8_t umode[32];
    uint16_t uwidth;
    uint16_t uheight;
    uint16_t padding_right;
    uint16_t padding_down;
    uint32_t unknown_block[6];
    uint16_t transform;
    uint16_t format;
    uint8_t bayer_order;
    uint8_t bayer_format;
  } header;

  header.bayer_order = 0;
  fseek (ifp, 0xb0 - 0x20, SEEK_CUR);
  fread (&header, 1, sizeof(header), ifp);
  raw_stride = ((((((header.uwidth + header.padding_right)*5)+3)>>2) + 0x1f)&(~0x1f));
  raw_width = width = header.uwidth;
  raw_height = height = header.uheight;
  filters = 0x16161616;  /* default Bayer order is 2, BGGR */

  switch (header.bayer_order) {
    case 0: /* RGGB */
      filters = 0x94949494;
      break;
    case 1: /* GBRG */
      filters = 0x49494949;
      break;
    case 3: /* GRBG */
      filters = 0x61616161;
      break;
  }
}


static void copy_task_thread_func ( GTask * task , gpointer source_object , gpointer task_data , GCancellable * cancellable ) {
 CopyMoveJob * job ;
 CommonJob * common ;
 SourceInfo source_info ;
 TransferInfo transfer_info ;
 char * dest_fs_id ;
 GFile * dest ;
 job = task_data ;
 common = & job -> common ;
 dest_fs_id = NULL ;
 nautilus_progress_info_start ( job -> common . progress ) ;
 scan_sources ( job -> files , & source_info , common , OP_KIND_COPY ) ;
 if ( job_aborted ( common ) ) {
 goto aborted ;
 }
 if ( job -> destination ) {
 dest = g_object_ref ( job -> destination ) ;
 }
 else {
 dest = g_file_get_parent ( job -> files -> data ) ;
 }
 verify_destination ( & job -> common , dest , & dest_fs_id , source_info . num_bytes ) ;
 g_object_unref ( dest ) ;
 if ( job_aborted ( common ) ) {
 goto aborted ;
 }
 g_timer_start ( job -> common . time ) ;
 memset ( & transfer_info , 0 , sizeof ( transfer_info ) ) ;
 copy_files ( job , dest_fs_id , & source_info , & transfer_info ) ;
 aborted : g_free ( dest_fs_id ) ;
 }


PHP_FUNCTION(stream_set_timeout)
{
	zval *socket;
	long seconds, microseconds = 0;
	struct timeval t;
	php_stream *stream;
	int argc = ZEND_NUM_ARGS();

	if (zend_parse_parameters(argc TSRMLS_CC, "rl|l", &socket, &seconds, &microseconds) == FAILURE) {
		return;
	}

	php_stream_from_zval(stream, &socket);

	t.tv_sec = seconds;

	if (argc == 3) {
		t.tv_usec = microseconds % 1000000;
		t.tv_sec += microseconds / 1000000;
	} else {
		t.tv_usec = 0;
	}

	if (PHP_STREAM_OPTION_RETURN_OK == php_stream_set_option(stream, PHP_STREAM_OPTION_READ_TIMEOUT, 0, &t)) {
		RETURN_TRUE;
	}

	RETURN_FALSE;
}


static BOOL rdp_print_control_capability_set(wStream* s, UINT16 length)
{
	UINT16 controlFlags;
	UINT16 remoteDetachFlag;
	UINT16 controlInterest;
	UINT16 detachInterest;
	WLog_INFO(TAG, "ControlCapabilitySet (length %" PRIu16 "):", length);

	if (length < 12)
		return FALSE;

	Stream_Read_UINT16(s, controlFlags);     /* controlFlags (2 bytes) */
	Stream_Read_UINT16(s, remoteDetachFlag); /* remoteDetachFlag (2 bytes) */
	Stream_Read_UINT16(s, controlInterest);  /* controlInterest (2 bytes) */
	Stream_Read_UINT16(s, detachInterest);   /* detachInterest (2 bytes) */
	WLog_INFO(TAG, "\tcontrolFlags: 0x%04" PRIX16 "", controlFlags);
	WLog_INFO(TAG, "\tremoteDetachFlag: 0x%04" PRIX16 "", remoteDetachFlag);
	WLog_INFO(TAG, "\tcontrolInterest: 0x%04" PRIX16 "", controlInterest);
	WLog_INFO(TAG, "\tdetachInterest: 0x%04" PRIX16 "", detachInterest);
	return TRUE;
}


void ParamTraits<LogData>::Write(Message* m, const param_type& p) {
  WriteParam(m, p.channel);
  WriteParam(m, p.routing_id);
  WriteParam(m, p.type);
  WriteParam(m, p.flags);
  WriteParam(m, p.sent);
  WriteParam(m, p.receive);
  WriteParam(m, p.dispatch);
  WriteParam(m, p.message_name);
  WriteParam(m, p.params);
}


NGConstraintSpace NGColumnLayoutAlgorithm::CreateConstraintSpaceForMinMax()
    const {
  NGConstraintSpaceBuilder space_builder(
      ConstraintSpace(), Style().GetWritingMode(), /* is_new_fc */ true);
  space_builder.SetIsAnonymous(true);
  space_builder.SetIsIntermediateLayout(true);

  return space_builder.ToConstraintSpace();
}


static void hns_nic_drop_rx_fetch(struct hns_nic_ring_data *ring_data,
				  struct sk_buff *skb)
{
	dev_kfree_skb_any(skb);
}


static BrotliResult WriteRingBuffer(size_t* available_out, uint8_t** next_out,
    size_t* total_out, BrotliState* s) {
  size_t pos = (s->pos > s->ringbuffer_size) ?
      (size_t)s->ringbuffer_size : (size_t)(s->pos);
  uint8_t* start = s->ringbuffer
      + (s->partial_pos_out & (size_t)s->ringbuffer_mask);
  size_t partial_pos_rb =
      (s->rb_roundtrips * (size_t)s->ringbuffer_size) + pos;
  size_t to_write = (partial_pos_rb - s->partial_pos_out);
  size_t num_written = *available_out;
  if (num_written > to_write) {
    num_written = to_write;
  }
  if (s->meta_block_remaining_len < 0) {
    return BROTLI_FAILURE();
  }
  memcpy(*next_out, start, num_written);
  *next_out += num_written;
  *available_out -= num_written;
  BROTLI_LOG_UINT(to_write);
  BROTLI_LOG_UINT(num_written);
  s->partial_pos_out += (size_t)num_written;
  *total_out = s->partial_pos_out;
  if (num_written < to_write) {
    return BROTLI_RESULT_NEEDS_MORE_OUTPUT;
  }
  return BROTLI_RESULT_SUCCESS;
}


Jsi_OptionsGet(Jsi_Interp *interp, Jsi_OptionSpec *specs, void *rec, const char *option, Jsi_Value** valuePtr, Jsi_Wide flags)
{
    char *record = (char*)rec;
    Jsi_OptionSpec *specPtr;
    const char *cp = NULL, *cb = NULL;
    if (option) {
        cp = Jsi_Strchr(option, '.');
        cb = Jsi_Strchr(option, '[');
    }
    if (cp && (!cb || cp<cb) ) {
        Jsi_DString dStr;
        int len = (cp-option);
        Jsi_DSInit(&dStr);
        cp = Jsi_DSAppendLen(&dStr, option, len);
        specPtr = Jsi_OptionsFind(interp, specs, cp, flags);
        Jsi_DSFree(&dStr);
        if (!specPtr || !specPtr->data || specPtr->id != JSI_OPTION_CUSTOM || specPtr->custom != Jsi_Opt_SwitchSuboption)
            return Jsi_LogError("unknown or bad sub-config option: %s", option);
        cp = option+len+1;
        return Jsi_OptionsGet(interp, (Jsi_OptionSpec *)(specPtr->data), (void*)(((char*)rec)+specPtr->offset), cp, valuePtr, flags);
    }
    if (cb && cb != option) {
        char *ce = Jsi_Strchr(option, ']');
        Jsi_Wide ul;
        Jsi_DString dStr;
        Jsi_DSInit(&dStr);
        int len = 0;
        if (ce && ce>cb) {
            len = (ce-cb-1);
            cp = Jsi_DSAppendLen(&dStr, cb+1, len);
        }
        if (len <= 0 || Jsi_GetWide(interp, cp, &ul, 0) != JSI_OK || ul<0)
            return Jsi_LogError("bad sub-array option: %s", option);
        len = (cb-option);
        Jsi_DSSetLength(&dStr, 0);
        cp = Jsi_DSAppendLen(&dStr, option, len);
        specPtr = Jsi_OptionsFind(interp, specs, cp, flags);
        Jsi_DSFree(&dStr);
        if (!specPtr || !specPtr->init.OPT_CARRAY|| specPtr->id != JSI_OPTION_CUSTOM || specPtr->custom != Jsi_Opt_SwitchCArray) {
bail:
            return Jsi_LogError("unknown or bad array option: %s", option);
        }
        cp = cb+1;
        Jsi_OptionSpec *subSpec = specPtr->init.OPT_CARRAY;
        int isize, size = specPtr->arrSize;
        if (!subSpec || size<=0 || (isize=subSpec->size)<=0)
            goto bail;
        isize = isize/size;
        uchar *s = (((uchar*)rec)+specPtr->offset + isize*ul);
        if (ce[1] != '.' || !subSpec->data) {
            if (Jsi_OptionsGet(interp, subSpec, (void*)s, subSpec->name, valuePtr, flags) != JSI_OK)
                return JSI_ERROR;
        } else {
            if (Jsi_OptionsGet(interp, (Jsi_OptionSpec *)subSpec->data, (void*)s, ce+2, valuePtr, flags) != JSI_OK)
                return JSI_ERROR;
        }
        return JSI_OK;
    }

    specPtr = Jsi_OptionsFind(interp, specs, option, flags);
    if (specPtr == NULL || jsi_GetOption(interp, specPtr, record, option, valuePtr, flags) != JSI_OK) {
        return JSI_ERROR;
    }

    return JSI_OK;

}


cmdline_insert_reg(int *gotesc UNUSED)
{
    int		i;
    int		c;
    int		save_new_cmdpos = new_cmdpos;

#ifdef USE_ON_FLY_SCROLL
    dont_scroll = TRUE;	// disallow scrolling here
#endif
    putcmdline('"', TRUE);
    ++no_mapping;
    ++allow_keys;
    i = c = plain_vgetc();	// CTRL-R <char>
    if (i == Ctrl_O)
	i = Ctrl_R;		// CTRL-R CTRL-O == CTRL-R CTRL-R
    if (i == Ctrl_R)
	c = plain_vgetc();	// CTRL-R CTRL-R <char>
    extra_char = NUL;
    --no_mapping;
    --allow_keys;
#ifdef FEAT_EVAL
    /*
     * Insert the result of an expression.
     */
    new_cmdpos = -1;
    if (c == '=')
    {
	if (ccline.cmdfirstc == '='  // can't do this recursively
		|| cmdline_star > 0) // or when typing a password
	{
	    beep_flush();
	    c = ESC;
	}
	else
	    c = get_expr_register();
    }
#endif
    if (c != ESC)	    // use ESC to cancel inserting register
    {
	cmdline_paste(c, i == Ctrl_R, FALSE);

#ifdef FEAT_EVAL
	// When there was a serious error abort getting the
	// command line.
	if (aborting())
	{
	    *gotesc = TRUE;  // will free ccline.cmdbuff after
	    // putting it in history
	    return GOTO_NORMAL_MODE;
	}
#endif
	KeyTyped = FALSE;	// Don't do p_wc completion.
#ifdef FEAT_EVAL
	if (new_cmdpos >= 0)
	{
	    // set_cmdline_pos() was used
	    if (new_cmdpos > ccline.cmdlen)
		ccline.cmdpos = ccline.cmdlen;
	    else
		ccline.cmdpos = new_cmdpos;
	}
#endif
    }
    new_cmdpos = save_new_cmdpos;

    // remove the double quote
    redrawcmd();

    // The text has been stuffed, the command line didn't change yet.
    return CMDLINE_NOT_CHANGED;
}


ex_viminfo(
    exarg_T	*eap)
{
    char_u	*save_viminfo;

    save_viminfo = p_viminfo;
    if (*p_viminfo == NUL)
	p_viminfo = (char_u *)"'100";
    if (eap->cmdidx == CMD_rviminfo)
    {
	if (read_viminfo(eap->arg, VIF_WANT_INFO | VIF_WANT_MARKS
				  | (eap->forceit ? VIF_FORCEIT : 0)) == FAIL)
	    emsg(_(e_cannot_open_viminfo_file_for_reading));
    }
    else
	write_viminfo(eap->arg, eap->forceit);
    p_viminfo = save_viminfo;
}


isis_print_is_reach_subtlv(netdissect_options *ndo,
                           const uint8_t *tptr, u_int subt, u_int subl,
                           const char *ident)
{
        u_int te_class,priority_level,gmpls_switch_cap;
        union { /* int to float conversion buffer for several subTLVs */
            float f;
            uint32_t i;
        } bw;

        /* first lets see if we know the subTLVs name*/
	ND_PRINT((ndo, "%s%s subTLV #%u, length: %u",
	          ident, tok2str(isis_ext_is_reach_subtlv_values, "unknown", subt),
	          subt, subl));

	ND_TCHECK2(*tptr, subl);

        switch(subt) {
        case ISIS_SUBTLV_EXT_IS_REACH_ADMIN_GROUP:
        case ISIS_SUBTLV_EXT_IS_REACH_LINK_LOCAL_REMOTE_ID:
        case ISIS_SUBTLV_EXT_IS_REACH_LINK_REMOTE_ID:
	    if (subl >= 4) {
	      ND_PRINT((ndo, ", 0x%08x", EXTRACT_32BITS(tptr)));
	      if (subl == 8) /* rfc4205 */
	        ND_PRINT((ndo, ", 0x%08x", EXTRACT_32BITS(tptr+4)));
	    }
	    break;
        case ISIS_SUBTLV_EXT_IS_REACH_IPV4_INTF_ADDR:
        case ISIS_SUBTLV_EXT_IS_REACH_IPV4_NEIGHBOR_ADDR:
            if (subl >= sizeof(struct in_addr))
              ND_PRINT((ndo, ", %s", ipaddr_string(ndo, tptr)));
            break;
        case ISIS_SUBTLV_EXT_IS_REACH_MAX_LINK_BW :
	case ISIS_SUBTLV_EXT_IS_REACH_RESERVABLE_BW:
            if (subl >= 4) {
              bw.i = EXTRACT_32BITS(tptr);
              ND_PRINT((ndo, ", %.3f Mbps", bw.f * 8 / 1000000));
            }
            break;
        case ISIS_SUBTLV_EXT_IS_REACH_UNRESERVED_BW :
            if (subl >= 32) {
              for (te_class = 0; te_class < 8; te_class++) {
                bw.i = EXTRACT_32BITS(tptr);
                ND_PRINT((ndo, "%s  TE-Class %u: %.3f Mbps",
                       ident,
                       te_class,
                       bw.f * 8 / 1000000));
		tptr+=4;
	      }
            }
            break;
        case ISIS_SUBTLV_EXT_IS_REACH_BW_CONSTRAINTS: /* fall through */
        case ISIS_SUBTLV_EXT_IS_REACH_BW_CONSTRAINTS_OLD:
            ND_PRINT((ndo, "%sBandwidth Constraints Model ID: %s (%u)",
                   ident,
                   tok2str(diffserv_te_bc_values, "unknown", *tptr),
                   *tptr));
            tptr++;
            /* decode BCs until the subTLV ends */
            for (te_class = 0; te_class < (subl-1)/4; te_class++) {
                ND_TCHECK2(*tptr, 4);
                bw.i = EXTRACT_32BITS(tptr);
                ND_PRINT((ndo, "%s  Bandwidth constraint CT%u: %.3f Mbps",
                       ident,
                       te_class,
                       bw.f * 8 / 1000000));
		tptr+=4;
            }
            break;
        case ISIS_SUBTLV_EXT_IS_REACH_TE_METRIC:
            if (subl >= 3)
              ND_PRINT((ndo, ", %u", EXTRACT_24BITS(tptr)));
            break;
        case ISIS_SUBTLV_EXT_IS_REACH_LINK_ATTRIBUTE:
            if (subl == 2) {
               ND_PRINT((ndo, ", [ %s ] (0x%04x)",
                      bittok2str(isis_subtlv_link_attribute_values,
                                 "Unknown",
                                 EXTRACT_16BITS(tptr)),
                      EXTRACT_16BITS(tptr)));
            }
            break;
        case ISIS_SUBTLV_EXT_IS_REACH_LINK_PROTECTION_TYPE:
            if (subl >= 2) {
              ND_PRINT((ndo, ", %s, Priority %u",
		   bittok2str(gmpls_link_prot_values, "none", *tptr),
                   *(tptr+1)));
            }
            break;
        case ISIS_SUBTLV_SPB_METRIC:
            if (subl >= 6) {
              ND_PRINT((ndo, ", LM: %u", EXTRACT_24BITS(tptr)));
              tptr=tptr+3;
              ND_PRINT((ndo, ", P: %u", *(tptr)));
              tptr++;
              ND_PRINT((ndo, ", P-ID: %u", EXTRACT_16BITS(tptr)));
            }
            break;
        case ISIS_SUBTLV_EXT_IS_REACH_INTF_SW_CAP_DESCR:
            if (subl >= 36) {
              gmpls_switch_cap = *tptr;
              ND_PRINT((ndo, "%s  Interface Switching Capability:%s",
                   ident,
                   tok2str(gmpls_switch_cap_values, "Unknown", gmpls_switch_cap)));
              ND_PRINT((ndo, ", LSP Encoding: %s",
                   tok2str(gmpls_encoding_values, "Unknown", *(tptr + 1))));
	      tptr+=4;
              ND_PRINT((ndo, "%s  Max LSP Bandwidth:", ident));
              for (priority_level = 0; priority_level < 8; priority_level++) {
                bw.i = EXTRACT_32BITS(tptr);
                ND_PRINT((ndo, "%s    priority level %d: %.3f Mbps",
                       ident,
                       priority_level,
                       bw.f * 8 / 1000000));
		tptr+=4;
              }
              subl-=36;
              switch (gmpls_switch_cap) {
              case GMPLS_PSC1:
              case GMPLS_PSC2:
              case GMPLS_PSC3:
              case GMPLS_PSC4:
                ND_TCHECK2(*tptr, 6);
                bw.i = EXTRACT_32BITS(tptr);
                ND_PRINT((ndo, "%s  Min LSP Bandwidth: %.3f Mbps", ident, bw.f * 8 / 1000000));
                ND_PRINT((ndo, "%s  Interface MTU: %u", ident, EXTRACT_16BITS(tptr + 4)));
                break;
              case GMPLS_TSC:
                ND_TCHECK2(*tptr, 8);
                bw.i = EXTRACT_32BITS(tptr);
                ND_PRINT((ndo, "%s  Min LSP Bandwidth: %.3f Mbps", ident, bw.f * 8 / 1000000));
                ND_PRINT((ndo, "%s  Indication %s", ident,
                       tok2str(gmpls_switch_cap_tsc_indication_values, "Unknown (%u)", *(tptr + 4))));
                break;
              default:
                /* there is some optional stuff left to decode but this is as of yet
                   not specified so just lets hexdump what is left */
                if(subl>0){
                  if (!print_unknown_data(ndo, tptr, "\n\t\t    ", subl))
                    return(0);
                }
              }
            }
            break;
        default:
            if (!print_unknown_data(ndo, tptr, "\n\t\t    ", subl))
                return(0);
            break;
        }
        return(1);

trunc:
    return(0);
}


   MockDataWriter* NavigateAndReturnMockWriter(const GURL& url) {
    content::WebContentsTester* web_contents_tester =
        content::WebContentsTester::For(web_contents());
    EXPECT_TRUE(web_contents_tester);
    web_contents_tester->NavigateAndCommit(url);
    return static_cast<MockDataWriter*>(observer_->GetWriterForTesting());
  }


GF_Box *prft_New()
{
	ISOM_DECL_BOX_ALLOC(GF_ProducerReferenceTimeBox, GF_ISOM_BOX_TYPE_PRFT);
	return (GF_Box *)tmp;
}


sds sdsRemoveFreeSpace(sds s) {
    void *sh, *newsh;
    char type, oldtype = s[-1] & SDS_TYPE_MASK;
    int hdrlen, oldhdrlen = sdsHdrSize(oldtype);
    size_t len = sdslen(s);
    size_t avail = sdsavail(s);
    sh = (char*)s-oldhdrlen;

    /* Return ASAP if there is no space left. */
    if (avail == 0) return s;

    /* Check what would be the minimum SDS header that is just good enough to
     * fit this string. */
    type = sdsReqType(len);
    hdrlen = sdsHdrSize(type);

    /* If the type is the same, or at least a large enough type is still
     * required, we just realloc(), letting the allocator to do the copy
     * only if really needed. Otherwise if the change is huge, we manually
     * reallocate the string to use the different header type. */
    if (oldtype==type || type > SDS_TYPE_8) {
        newsh = s_realloc(sh, oldhdrlen+len+1);
        if (newsh == NULL) return NULL;
        s = (char*)newsh+oldhdrlen;
    } else {
        newsh = s_malloc(hdrlen+len+1);
        if (newsh == NULL) return NULL;
        memcpy((char*)newsh+hdrlen, s, len+1);
        s_free(sh);
        s = (char*)newsh+hdrlen;
        s[-1] = type;
        sdssetlen(s, len);
    }
    sdssetalloc(s, len);
    return s;
}


static int encode_putrootfh(struct xdr_stream *xdr)
{
        __be32 *p;

        RESERVE_SPACE(4);
        WRITE32(OP_PUTROOTFH);

        return 0;
}


void WebContentsImpl::FocusThroughTabTraversal(bool reverse) {
  if (ShowingInterstitialPage()) {
    GetRenderManager()->interstitial_page()->FocusThroughTabTraversal(reverse);
    return;
  }
  GetRenderViewHostImpl()->SetInitialFocus(reverse);
}


  BookmarkNode* GetMutableNode(const std::string& name) {
    return const_cast<BookmarkNode*>(GetNode(name));
  }


static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *exc_type1, PyObject *exc_type2) {
    assert(PyExceptionClass_Check(exc_type1));
    assert(PyExceptionClass_Check(exc_type2));
    if (likely(err == exc_type1 || err == exc_type2)) return 1;
    if (likely(PyExceptionClass_Check(err))) {
        return __Pyx_inner_PyErr_GivenExceptionMatches2(err, exc_type1, exc_type2);
    }
    return (PyErr_GivenExceptionMatches(err, exc_type1) || PyErr_GivenExceptionMatches(err, exc_type2));
}


ExtensionGlobalError::ExtensionGlobalError(
      base::WeakPtr<ExtensionService> extension_service)
    : current_browser_(NULL),
      should_delete_self_on_close_(true),
      extension_service_(extension_service),
      external_extension_ids_(new ExtensionIdSet),
      blacklisted_extension_ids_(new ExtensionIdSet),
      orphaned_extension_ids_(new ExtensionIdSet) {
}


xsltParseStylesheetCallerParam(xsltTransformContextPtr ctxt, xmlNodePtr inst)
{
#ifdef XSLT_REFACTORED
    xsltStyleBasicItemVariablePtr comp;
#else
    xsltStylePreCompPtr comp;
#endif
    xmlNodePtr tree = NULL; /* The first child node of the instruction or
                               the instruction itself. */
    xsltStackElemPtr param = NULL;

    if ((ctxt == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
	return(NULL);

#ifdef XSLT_REFACTORED
    comp = (xsltStyleBasicItemVariablePtr) inst->psvi;
#else
    comp = (xsltStylePreCompPtr) inst->psvi;
#endif

    if (comp == NULL) {
        xsltTransformError(ctxt, NULL, inst,
	    "Internal error in xsltParseStylesheetCallerParam(): "
	    "The XSLT 'with-param' instruction was not compiled.\n");
        return(NULL);
    }
    if (comp->name == NULL) {
	xsltTransformError(ctxt, NULL, inst,
	    "Internal error in xsltParseStylesheetCallerParam(): "
	    "XSLT 'with-param': The attribute 'name' was not compiled.\n");
	return(NULL);
    }

#ifdef WITH_XSLT_DEBUG_VARIABLE
    XSLT_TRACE(ctxt,XSLT_TRACE_VARIABLES,xsltGenericDebug(xsltGenericDebugContext,
	    "Handling xsl:with-param %s\n", comp->name));
#endif

    if (comp->select == NULL) {
	tree = inst->children;
    } else {
#ifdef WITH_XSLT_DEBUG_VARIABLE
	XSLT_TRACE(ctxt,XSLT_TRACE_VARIABLES,xsltGenericDebug(xsltGenericDebugContext,
	    "        select %s\n", comp->select));
#endif
	tree = inst;
    }

    param = xsltBuildVariable(ctxt, (xsltStylePreCompPtr) comp, tree);

    return(param);
}


int el_move_message(LOGBOOK *lbs, int old_id, int new_id) {
   int status, size;
   char date[80], attrib[MAX_N_ATTR][NAME_LENGTH], *text, in_reply_to[80], reply_to[MAX_REPLY_TO * 10],
           encoding[80], locked_by[256], draft[256], att_file[MAX_ATTACHMENTS][256];

   /* retrieve message */
   text = xmalloc(TEXT_SIZE);
   size = TEXT_SIZE;
   status = el_retrieve(lbs, old_id, date, attr_list, attrib, lbs->n_attr, text, &size, in_reply_to,
                        reply_to, att_file, encoding, locked_by, draft);
   if (status != EL_SUCCESS)
      return 0;

   /* submit as new message */
   status = el_submit(lbs, new_id, FALSE, date, attr_list, attrib, lbs->n_attr, text, in_reply_to, reply_to,
                      encoding, att_file, FALSE, locked_by, draft);

   xfree(text);

   if (status != new_id)
      return 0;

   /* correct links */
   el_correct_links(lbs, old_id, new_id);

   /* delete original message */
   el_delete_message(lbs, old_id, FALSE, NULL, FALSE, FALSE);

   return 1;
}


bool IsSameOriginWindowProviderHost(const GURL& origin,
                                    ServiceWorkerProviderHost* host) {
  return host->provider_type() ==
             blink::mojom::ServiceWorkerProviderType::kForWindow &&
         host->url().GetOrigin() == origin && host->is_execution_ready();
}


bool OutputFile::flush() {
  if (!isClosed()) {
    g_context->flush();
    return true;
  }
  return false;
}


void ShelfLayoutManager::UpdateGestureDrag(
    const ui::GestureEvent& gesture_in_screen) {
  if (ShouldHomeGestureHandleEvent(gesture_in_screen.details().scroll_y())) {
    HomeLauncherGestureHandler* home_launcher_handler =
        Shell::Get()->app_list_controller()->home_launcher_gesture_handler();
    if (home_launcher_handler->OnScrollEvent(
            gesture_in_screen.location(),
            gesture_in_screen.details().scroll_y())) {
      return;
    }
  }

  if (gesture_drag_status_ == GESTURE_DRAG_APPLIST_IN_PROGRESS) {
    if (!shelf_->IsHorizontalAlignment()) {
      Shell::Get()->app_list_controller()->DismissAppList();
      launcher_above_shelf_bottom_amount_ = 0.f;
      gesture_drag_status_ = GESTURE_DRAG_NONE;
      return;
    }
    const gfx::Rect shelf_bounds = GetIdealBounds();
    Shell::Get()->app_list_controller()->UpdateYPositionAndOpacity(
        std::min(gesture_in_screen.location().y(), shelf_bounds.y()),
        GetAppListBackgroundOpacityOnShelfOpacity());
    launcher_above_shelf_bottom_amount_ =
        shelf_bounds.bottom() - gesture_in_screen.location().y();
  } else {
    gesture_drag_amount_ +=
        PrimaryAxisValue(gesture_in_screen.details().scroll_y(),
                         gesture_in_screen.details().scroll_x());
    LayoutShelf();
  }
}


void ImportEPUB::ReadIdentifierElement(QXmlStreamReader *opf_reader)
{
    QString id     = opf_reader->attributes().value("", "id").toString();
    QString scheme = opf_reader->attributes().value("", "scheme").toString();
    QString value  = opf_reader->readElementText();

    if (id == m_UniqueIdentifierId) {
        m_UniqueIdentifierValue = value;
    }

    if (m_UuidIdentifierValue.isEmpty() &&
        (value.contains("urn:uuid:") || scheme.toLower() == "uuid")) {
        m_UuidIdentifierValue = value;
    }
}


static pj_bool_t ssock_on_connect_complete (pj_ssl_sock_t *ssock,
					    pj_status_t status)
{
    unsigned i;

    if (status != PJ_SUCCESS)
	goto on_return;

    /* Update local address */
    ssock->addr_len = sizeof(pj_sockaddr);
    status = get_localaddr(ssock, &ssock->local_addr, &ssock->addr_len);
    if (status != PJ_SUCCESS)
	goto on_return;

    /* Create SSL context */
    status = ssl_create(ssock);
    if (status != PJ_SUCCESS)
	goto on_return;

    /* Prepare read buffer */
    ssock->asock_rbuf = (void**)pj_pool_calloc(ssock->pool,
					       ssock->param.async_cnt,
					       sizeof(void*));
    if (!ssock->asock_rbuf)
        return PJ_ENOMEM;

    for (i = 0; i<ssock->param.async_cnt; ++i) {
	ssock->asock_rbuf[i] = (void*) pj_pool_alloc(
					    ssock->pool,
					    ssock->param.read_buffer_size +
					    sizeof(read_data_t*));
        if (!ssock->asock_rbuf[i])
            return PJ_ENOMEM;
    }

    /* Start read */
#ifdef SSL_SOCK_IMP_USE_OWN_NETWORK
    status = network_start_read(ssock, ssock->param.async_cnt,
    				(unsigned)ssock->param.read_buffer_size,
				ssock->asock_rbuf, 0);
#else
    status = pj_activesock_start_read2(ssock->asock, ssock->pool,
				       (unsigned)ssock->param.read_buffer_size,
				       ssock->asock_rbuf,
				       PJ_IOQUEUE_ALWAYS_ASYNC);
#endif
    if (status != PJ_SUCCESS)
	goto on_return;

    /* Prepare write/send state */
    pj_assert(ssock->send_buf.max_len == 0);
    ssock->send_buf.buf = (char*)
			     pj_pool_alloc(ssock->pool,
					   ssock->param.send_buffer_size);
    if (!ssock->send_buf.buf)
        return PJ_ENOMEM;

    ssock->send_buf.max_len = ssock->param.send_buffer_size;
    ssock->send_buf.start = ssock->send_buf.buf;
    ssock->send_buf.len = 0;

    /* Set peer name */
    ssl_set_peer_name(ssock);

    /* Start SSL handshake */
    ssock->ssl_state = SSL_STATE_HANDSHAKING;
    ssl_set_state(ssock, PJ_FALSE);

    status = ssl_do_handshake(ssock);
    if (status != PJ_EPENDING)
	goto on_return;

    return PJ_TRUE;

on_return:
    return on_handshake_complete(ssock, status);
}


static struct pending_req *alloc_req(struct xen_blkif *blkif)
{
	struct pending_req *req = NULL;
	unsigned long flags;

	spin_lock_irqsave(&blkif->pending_free_lock, flags);
	if (!list_empty(&blkif->pending_free)) {
		req = list_entry(blkif->pending_free.next, struct pending_req,
				 free_list);
		list_del(&req->free_list);
	}
	spin_unlock_irqrestore(&blkif->pending_free_lock, flags);
	return req;
}


static void snd_timer_process_callbacks(struct snd_timer *timer,
					struct list_head *head)
{
	struct snd_timer_instance *ti;
	unsigned long resolution, ticks;

	while (!list_empty(head)) {
		ti = list_first_entry(head, struct snd_timer_instance,
				      ack_list);

		/* remove from ack_list and make empty */
		list_del_init(&ti->ack_list);

		if (!(ti->flags & SNDRV_TIMER_IFLG_DEAD)) {
			ticks = ti->pticks;
			ti->pticks = 0;
			resolution = ti->resolution;
			ti->flags |= SNDRV_TIMER_IFLG_CALLBACK;
			spin_unlock(&timer->lock);
			if (ti->callback)
				ti->callback(ti, resolution, ticks);
			spin_lock(&timer->lock);
			ti->flags &= ~SNDRV_TIMER_IFLG_CALLBACK;
		}
	}
}


AutomationProviderDownloadModelChangedObserver(
    AutomationProvider* provider,
    IPC::Message* reply_message,
    DownloadManager* download_manager)
    : provider_(provider->AsWeakPtr()),
      reply_message_(reply_message),
      ALLOW_THIS_IN_INITIALIZER_LIST(notifier_(download_manager, this)) {
}


void Context::onGrpcReceiveTrailingMetadata(uint32_t token, Http::HeaderMapPtr&& metadata) {
  if (!wasm_->onGrpcReceiveTrailingMetadata_) {
    return;
  }
  grpc_receive_trailing_metadata_ = std::move(metadata);
  wasm_->onGrpcReceiveTrailingMetadata_(this, id_, token);
  grpc_receive_trailing_metadata_ = nullptr;
}


static void rgb_to_lab ( fz_context * ctx , const fz_colorspace * cs , const float * rgb , float * lab ) {
 fz_warn ( ctx , "cannot convert into L*a*b colorspace" ) ;
 lab [ 0 ] = rgb [ 0 ] ;
 lab [ 1 ] = rgb [ 1 ] ;
 lab [ 2 ] = rgb [ 2 ] ;
 }


int qemu_acl_party_is_allowed(qemu_acl *acl,

                              const char *party)

{

    qemu_acl_entry *entry;

    TAILQ_FOREACH(entry, &acl->entries, next) {

#ifdef CONFIG_FNMATCH

        if (fnmatch(entry->match, party, 0) == 0)

            return entry->deny ? 0 : 1;

#else

        /* No fnmatch, so fallback to exact string matching

         * instead of allowing wildcards */

        if (strcmp(entry->match, party) == 0)

            return entry->deny ? 0 : 1;

#endif

    }

    return acl->defaultDeny ? 0 : 1;

}


EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionIntMethodWithArgs(ExecState* exec)
{
    JSValue thisValue = exec->hostThisValue();
    if (!thisValue.inherits(&JSTestObj::s_info))
        return throwVMTypeError(exec);
    JSTestObj* castedThis = jsCast<JSTestObj*>(asObject(thisValue));
     ASSERT_GC_OBJECT_INHERITS(castedThis, &JSTestObj::s_info);
     TestObj* impl = static_cast<TestObj*>(castedThis->impl());
     if (exec->argumentCount() < 3)
        return throwVMError(exec, createNotEnoughArgumentsError(exec));
     int intArg(MAYBE_MISSING_PARAMETER(exec, 0, DefaultIsUndefined).toInt32(exec));
     if (exec->hadException())
         return JSValue::encode(jsUndefined());
    const String& strArg(ustringToString(MAYBE_MISSING_PARAMETER(exec, 1, DefaultIsUndefined).isEmpty() ? UString() : MAYBE_MISSING_PARAMETER(exec, 1, DefaultIsUndefined).toString(exec)->value(exec)));
    if (exec->hadException())
        return JSValue::encode(jsUndefined());
    TestObj* objArg(toTestObj(MAYBE_MISSING_PARAMETER(exec, 2, DefaultIsUndefined)));
    if (exec->hadException())
        return JSValue::encode(jsUndefined());

    JSC::JSValue result = jsNumber(impl->intMethodWithArgs(intArg, strArg, objArg));
    return JSValue::encode(result);
}


PCIBus *pci_device_root_bus(const PCIDevice *d)

{

    PCIBus *bus = d->bus;

    while (!pci_bus_is_root(bus)) {

        d = bus->parent_dev;

        assert(d != NULL);

        bus = d->bus;

    }

    return bus;

}


bool Extension::HasApiPermission(
    const std::set<std::string>& api_permissions,
    const std::string& function_name) {
  std::string permission_name = function_name;

  for (size_t i = 0; i < kNumNonPermissionFunctionNames; ++i) {
    if (permission_name == kNonPermissionFunctionNames[i])
      return true;
  }

  size_t separator = function_name.find_first_of("./");
  if (separator != std::string::npos)
    permission_name = function_name.substr(0, separator);

  if (permission_name == kWindowPermission)
    permission_name = Extension::kTabPermission;

  if (api_permissions.count(permission_name))
    return true;

  for (size_t i = 0; i < kNumNonPermissionModuleNames; ++i) {
    if (permission_name == kNonPermissionModuleNames[i]) {
      return true;
    }
  }

  return false;
}


void cil_destroy_level(struct cil_level *level)
{
	if (level == NULL) {
		return;
	}

	cil_symtab_datum_destroy(&level->datum);

	cil_destroy_cats(level->cats);

	free(level);
}


ClientConnectionImpl::ClientConnectionImpl(Network::Connection& connection, Stats::Scope& stats,
                                           ConnectionCallbacks&)
    : ConnectionImpl(connection, stats, HTTP_RESPONSE, MAX_RESPONSE_HEADERS_KB) {}


flatpak_run_get_pulse_home (void)
{
  /* Legacy path ~/.pulse is tried first, for compatibility */
  {
    const char *parent = g_get_home_dir ();
    g_autofree char *ret = g_build_filename (parent, ".pulse", NULL);

    if (g_file_test (ret, G_FILE_TEST_IS_DIR))
      return g_steal_pointer (&ret);
  }

  /* The more modern path, usually ~/.config/pulse */
  {
    const char *parent = g_get_user_config_dir ();
    /* Usually ~/.config/pulse */
    g_autofree char *ret = g_build_filename (parent, "pulse", NULL);

    if (g_file_test (ret, G_FILE_TEST_IS_DIR))
      return g_steal_pointer (&ret);
  }

  return NULL;
}


ves_icall_System_Threading_Thread_GetState (MonoInternalThread* this)
{
	guint32 state;

	ensure_synch_cs_set (this);

	EnterCriticalSection (this->synch_cs);

	state = this->state;

	LeaveCriticalSection (this->synch_cs);

	return state;
}


void InspectorNetworkAgent::DidSendWebSocketFrame(unsigned long identifier,
                                                  int op_code,
                                                  bool masked,
                                                  const char* payload,
                                                  size_t payload_length) {
  std::unique_ptr<protocol::Network::WebSocketFrame> frame_object =
      protocol::Network::WebSocketFrame::create()
          .setOpcode(op_code)
          .setMask(masked)
          .setPayloadData(
              String::FromUTF8WithLatin1Fallback(payload, payload_length))
          .build();
  GetFrontend()->webSocketFrameSent(IdentifiersFactory::RequestId(identifier),
                                    MonotonicallyIncreasingTime(),
                                    std::move(frame_object));
}


TEST_P(DownstreamProtocolIntegrationTest, InvalidContentLength) {
  initialize();

  codec_client_ = makeHttpConnection(lookupPort("http"));

  auto encoder_decoder =
      codec_client_->startRequest(Http::TestHeaderMapImpl{{":method", "POST"},
                                                          {":path", "/test/long/url"},
                                                          {":authority", "host"},
                                                          {"content-length", "-1"}});
  auto response = std::move(encoder_decoder.second);

  codec_client_->waitForDisconnect();

  if (downstream_protocol_ == Http::CodecClient::Type::HTTP1) {
    ASSERT_TRUE(response->complete());
    EXPECT_EQ("400", response->headers().Status()->value().getStringView());
  } else {
    ASSERT_TRUE(response->reset());
    EXPECT_EQ(Http::StreamResetReason::ConnectionTermination, response->reset_reason());
  }
}


void MessageService::OpenChannelToExtension(
    int source_process_id, int source_routing_id, int receiver_port_id,
    const std::string& source_extension_id,
    const std::string& target_extension_id,
    const std::string& channel_name) {
  content::RenderProcessHost* source =
      content::RenderProcessHost::FromID(source_process_id);
  if (!source)
    return;
  Profile* profile = Profile::FromBrowserContext(source->GetBrowserContext());

  MessagePort* receiver = new ExtensionMessagePort(
      GetExtensionProcess(profile, target_extension_id), MSG_ROUTING_CONTROL,
      target_extension_id);
  WebContents* source_contents = tab_util::GetWebContentsByID(
      source_process_id, source_routing_id);

   std::string tab_json = "null";
   if (source_contents) {
     scoped_ptr<DictionaryValue> tab_value(ExtensionTabUtil::CreateTabValue(
        source_contents, ExtensionTabUtil::INCLUDE_PRIVACY_SENSITIVE_FIELDS));
     base::JSONWriter::Write(tab_value.get(), &tab_json);
   }

  OpenChannelParams* params = new OpenChannelParams(source, tab_json, receiver,
                                                    receiver_port_id,
                                                    source_extension_id,
                                                    target_extension_id,
                                                    channel_name);

  if (MaybeAddPendingOpenChannelTask(profile, params)) {
    return;
  }

  OpenChannelImpl(scoped_ptr<OpenChannelParams>(params));
}


    template<typename t>
    void _eik_priority_queue_insert(CImg<charT>& state, unsigned int& siz, const t value,
                                    const unsigned int x, const unsigned int y, const unsigned int z) {
      if (state(x,y,z)>0) return;
      state(x,y,z) = 0;
      if (++siz>=_width) { if (!is_empty()) resize(_width*2,4,1,1,0); else assign(64,4); }
      (*this)(siz - 1,0) = (T)value; (*this)(siz - 1,1) = (T)x; (*this)(siz - 1,2) = (T)y; (*this)(siz - 1,3) = (T)z;
      for (unsigned int pos = siz - 1, par = 0; pos && value>(t)(*this)(par=(pos + 1)/2 - 1,0); pos = par) {
        cimg::swap((*this)(pos,0),(*this)(par,0)); cimg::swap((*this)(pos,1),(*this)(par,1));
        cimg::swap((*this)(pos,2),(*this)(par,2)); cimg::swap((*this)(pos,3),(*this)(par,3));
      }


static sds cliVersion(void) {
    sds version;
    version = sdscatprintf(sdsempty(), "%s", REDIS_VERSION);

    /* Add git commit and working tree status when available */
    if (strtoll(redisGitSHA1(),NULL,16)) {
        version = sdscatprintf(version, " (git:%s", redisGitSHA1());
        if (strtoll(redisGitDirty(),NULL,10))
            version = sdscatprintf(version, "-dirty");
        version = sdscat(version, ")");
    }
    return version;
}


static void vmxnet3_process_tx_queue(VMXNET3State *s, int qidx)
{
    struct Vmxnet3_TxDesc txd;
    uint32_t txd_idx;
    uint32_t data_len;
    hwaddr data_pa;

    for (;;) {
        if (!vmxnet3_pop_next_tx_descr(s, qidx, &txd, &txd_idx)) {
            break;
        }

        vmxnet3_dump_tx_descr(&txd);

        if (!s->skip_current_tx_pkt) {
            data_len = (txd.len > 0) ? txd.len : VMXNET3_MAX_TX_BUF_SIZE;
            data_pa = le64_to_cpu(txd.addr);

            if (!net_tx_pkt_add_raw_fragment(s->tx_pkt,
                                                data_pa,
                                                data_len)) {
                s->skip_current_tx_pkt = true;
            }
        }

        if (s->tx_sop) {
            vmxnet3_tx_retrieve_metadata(s, &txd);
            s->tx_sop = false;
        }

        if (txd.eop) {
            if (!s->skip_current_tx_pkt && net_tx_pkt_parse(s->tx_pkt)) {
                if (s->needs_vlan) {
                    net_tx_pkt_setup_vlan_header(s->tx_pkt, s->tci);
                }

                vmxnet3_send_packet(s, qidx);
            } else {
                vmxnet3_on_tx_done_update_stats(s, qidx,
                                                VMXNET3_PKT_STATUS_ERROR);
            }

            vmxnet3_complete_packet(s, qidx, txd_idx);
            s->tx_sop = true;
            s->skip_current_tx_pkt = false;
            net_tx_pkt_reset(s->tx_pkt);
        }
    }
}


TEE_Result syscall_authenc_dec_final(unsigned long state,
			const void *src_data, size_t src_len, void *dst_data,
			uint64_t *dst_len, const void *tag, size_t tag_len)
{
	TEE_Result res;
	struct tee_cryp_state *cs;
	struct tee_ta_session *sess;
	size_t dlen = 0;

	res = tee_ta_get_current_session(&sess);
	if (res != TEE_SUCCESS)
		return res;

	res = tee_svc_cryp_get_state(sess, tee_svc_uref_to_vaddr(state), &cs);
	if (res != TEE_SUCCESS)
		return res;

	if (cs->state != CRYP_STATE_INITIALIZED)
		return TEE_ERROR_BAD_STATE;

	if (cs->mode != TEE_MODE_DECRYPT)
		return TEE_ERROR_BAD_PARAMETERS;

	if (TEE_ALG_GET_CLASS(cs->algo) != TEE_OPERATION_AE)
		return TEE_ERROR_BAD_STATE;

	res = tee_mmu_check_access_rights(to_user_ta_ctx(sess->ctx),
					  TEE_MEMORY_ACCESS_READ |
					  TEE_MEMORY_ACCESS_ANY_OWNER,
					  (uaddr_t)src_data, src_len);
	if (res != TEE_SUCCESS)
		return res;

	if (!dst_len) {
		dlen = 0;
	} else {
		res = get_user_u64_as_size_t(&dlen, dst_len);
		if (res != TEE_SUCCESS)
			return res;

		res = tee_mmu_check_access_rights(to_user_ta_ctx(sess->ctx),
						  TEE_MEMORY_ACCESS_READ |
						  TEE_MEMORY_ACCESS_WRITE |
						  TEE_MEMORY_ACCESS_ANY_OWNER,
						  (uaddr_t)dst_data, dlen);
		if (res != TEE_SUCCESS)
			return res;
	}

	if (dlen < src_len) {
		res = TEE_ERROR_SHORT_BUFFER;
		goto out;
	}

	res = tee_mmu_check_access_rights(to_user_ta_ctx(sess->ctx),
					  TEE_MEMORY_ACCESS_READ |
					  TEE_MEMORY_ACCESS_ANY_OWNER,
					  (uaddr_t)tag, tag_len);
	if (res != TEE_SUCCESS)
		return res;

	res = crypto_authenc_dec_final(cs->ctx, cs->algo, src_data, src_len,
				       dst_data, &dlen, tag, tag_len);

out:
	if ((res == TEE_SUCCESS || res == TEE_ERROR_SHORT_BUFFER) &&
	    dst_len != NULL) {
		TEE_Result res2 = put_user_u64(dst_len, dlen);

		if (res2 != TEE_SUCCESS)
			return res2;
	}

	return res;
}


error::Error GLES2DecoderImpl::HandleReadPixels(
    uint32 immediate_data_size, const gles2::ReadPixels& c) {
  GLint x = c.x;
  GLint y = c.y;
  GLsizei width = c.width;
  GLsizei height = c.height;
  GLenum format = c.format;
  GLenum type = c.type;
  if (width < 0 || height < 0) {
    SetGLError(GL_INVALID_VALUE, "glReadPixels: dimensions < 0");
    return error::kNoError;
  }
  typedef gles2::ReadPixels::Result Result;
  uint32 pixels_size;
  if (!GLES2Util::ComputeImageDataSize(
      width, height, format, type, pack_alignment_, &pixels_size)) {
    return error::kOutOfBounds;
  }
  void* pixels = GetSharedMemoryAs<void*>(
      c.pixels_shm_id, c.pixels_shm_offset, pixels_size);
  Result* result = GetSharedMemoryAs<Result*>(
        c.result_shm_id, c.result_shm_offset, sizeof(*result));
  if (!pixels || !result) {
    return error::kOutOfBounds;
  }

  if (!validators_->read_pixel_format.IsValid(format)) {
    SetGLError(GL_INVALID_ENUM, "glReadPixels: format GL_INVALID_ENUM");
    return error::kNoError;
  }
  if (!validators_->pixel_type.IsValid(type)) {
    SetGLError(GL_INVALID_ENUM, "glReadPixels: type GL_INVALID_ENUM");
    return error::kNoError;
  }
  if (width == 0 || height == 0) {
    return error::kNoError;
  }

  CopyRealGLErrorsToWrapper();

  ScopedResolvedFrameBufferBinder binder(this, false, true);

  gfx::Size max_size = GetBoundReadFrameBufferSize();

  GLint max_x;
  GLint max_y;
  if (!SafeAdd(x, width, &max_x) || !SafeAdd(y, height, &max_y)) {
    SetGLError(GL_INVALID_VALUE, "glReadPixels: dimensions out of range");
    return error::kNoError;
  }

  if (x < 0 || y < 0 || max_x > max_size.width() || max_y > max_size.height()) {
    uint32 temp_size;
    if (!GLES2Util::ComputeImageDataSize(
        width, 1, format, type, pack_alignment_, &temp_size)) {
      SetGLError(GL_INVALID_VALUE, "glReadPixels: dimensions out of range");
      return error::kNoError;
    }
    GLsizei unpadded_row_size = temp_size;
    if (!GLES2Util::ComputeImageDataSize(
        width, 2, format, type, pack_alignment_, &temp_size)) {
      SetGLError(GL_INVALID_VALUE, "glReadPixels: dimensions out of range");
      return error::kNoError;
    }
    GLsizei padded_row_size = temp_size - unpadded_row_size;
    if (padded_row_size < 0 || unpadded_row_size < 0) {
      SetGLError(GL_INVALID_VALUE, "glReadPixels: dimensions out of range");
      return error::kNoError;
    }

    GLint dest_x_offset = std::max(-x, 0);
    uint32 dest_row_offset;
    if (!GLES2Util::ComputeImageDataSize(
      dest_x_offset, 1, format, type, pack_alignment_, &dest_row_offset)) {
      SetGLError(GL_INVALID_VALUE, "glReadPixels: dimensions out of range");
      return error::kNoError;
    }

    int8* dst = static_cast<int8*>(pixels);
    GLint read_x = std::max(0, x);
    GLint read_end_x = std::max(0, std::min(max_size.width(), max_x));
    GLint read_width = read_end_x - read_x;
    for (GLint yy = 0; yy < height; ++yy) {
      GLint ry = y + yy;

      memset(dst, 0, unpadded_row_size);

      if (ry >= 0 && ry < max_size.height() && read_width > 0) {
        glReadPixels(
            read_x, ry, read_width, 1, format, type, dst + dest_row_offset);
      }
      dst += padded_row_size;
    }
  } else {
    glReadPixels(x, y, width, height, format, type, pixels);
  }
  GLenum error = PeekGLError();
  if (error == GL_NO_ERROR) {
    *result = true;

    GLenum read_format = GetBoundReadFrameBufferInternalFormat();
    uint32 channels_exist = GLES2Util::GetChannelsForFormat(read_format);
    if ((channels_exist & 0x0008) == 0) {
      uint32 temp_size;
      if (!GLES2Util::ComputeImageDataSize(
          width, 1, format, type, pack_alignment_, &temp_size)) {
        SetGLError(GL_INVALID_VALUE, "glReadPixels: dimensions out of range");
        return error::kNoError;
      }
      GLsizei unpadded_row_size = temp_size;
      if (!GLES2Util::ComputeImageDataSize(
          width, 2, format, type, pack_alignment_, &temp_size)) {
        SetGLError(GL_INVALID_VALUE, "glReadPixels: dimensions out of range");
        return error::kNoError;
      }
      GLsizei padded_row_size = temp_size - unpadded_row_size;
      if (padded_row_size < 0 || unpadded_row_size < 0) {
        SetGLError(GL_INVALID_VALUE, "glReadPixels: dimensions out of range");
        return error::kNoError;
      }
      if (type != GL_UNSIGNED_BYTE) {
        SetGLError(GL_INVALID_OPERATION, "unsupported readPixel format");
        return error::kNoError;
      }
      switch (format) {
        case GL_RGBA:
        case GL_BGRA_EXT:
        case GL_ALPHA: {
          int offset = (format == GL_ALPHA) ? 0 : 3;
          int step = (format == GL_ALPHA) ? 1 : 4;
          uint8* dst = static_cast<uint8*>(pixels) + offset;
          for (GLint yy = 0; yy < height; ++yy) {
            uint8* end = dst + unpadded_row_size;
            for (uint8* d = dst; d < end; d += step) {
              *d = 255;
            }
            dst += padded_row_size;
          }
          break;
        }
        default:
          break;
      }
    }
  }

  return error::kNoError;
}


static Array memcache_build_stats(const memcached_st *ptr,
                                memcached_stat_st *memc_stat,
                                memcached_return_t *ret) {
  char **curr_key;
  char **stat_keys = memcached_stat_get_keys(const_cast<memcached_st*>(ptr),
                                             memc_stat, ret);

  if (*ret != MEMCACHED_SUCCESS) {
    if (stat_keys) {
      free(stat_keys);
    }
    return Array();
  }

  Array return_val = Array::Create();

  for (curr_key = stat_keys; *curr_key; curr_key++) {
    char *mc_val;
    mc_val = memcached_stat_get_value(ptr, memc_stat, *curr_key, ret);
    if (*ret != MEMCACHED_SUCCESS) {
      break;
    }
    return_val.set(String(*curr_key, CopyString),
                   String(mc_val, CopyString));
    free(mc_val);
  }

  free(stat_keys);
  return return_val;
}


static void * i_alloc_struct_array_immovable ( gs_memory_t * mem , uint num_elements , gs_memory_type_ptr_t pstype , client_name_t cname ) {
 gs_ref_memory_t * const imem = ( gs_ref_memory_t * ) mem ;
 obj_header_t * obj ;
 # ifdef MEMENTO if ( Memento_failThisEvent ( ) ) return NULL ;
 # endif ALLOC_CHECK_SIZE ( mem , pstype ) ;
 obj = alloc_obj ( imem , ( ulong ) num_elements * pstype -> ssize , pstype , ALLOC_IMMOVABLE | ALLOC_DIRECT , cname ) ;
 if_debug7m ( 'A' , mem , "[a%d|+<.]%s %s*(%lu=%u*%u) = 0x%lx\n" , alloc_trace_space ( imem ) , client_name_string ( cname ) , struct_type_name_string ( pstype ) , ( ulong ) num_elements * pstype -> ssize , num_elements , pstype -> ssize , ( ulong ) obj ) ;
 return ( char * ) obj ;
 }


bool FileManagerBrowserTestBase::GetEnableMyFilesVolume() const {
  return false;
}