diff --git a/PrintS/Config/ConfigManager.cpp b/PrintS/Config/ConfigManager.cpp
index 5ce60af..5bc8622 100644
--- a/PrintS/Config/ConfigManager.cpp
+++ b/PrintS/Config/ConfigManager.cpp
@@ -492,13 +492,6 @@ void ConfigManager::SendCfgToClients() {
 
 	SendAlarmCfg();
 	SendPowderCfg();
-	
-	//int index = 0;
-	//auto  item = m_ScannerControlCfgDao->m_ScannerControlCfgMap.begin();
-	//while (item != m_ScannerControlCfgDao->m_ScannerControlCfgMap.end()) {
-	//	//item->second->SendToClients();
-	//	++item;
-	//}
 
 	m_MoldCfg->SendToClients(MOLDCFGPARAM);
 	m_LoadCfg->SendToClients(LOADCFGPARAM);
@@ -532,42 +525,60 @@ void ConfigManager::CallFuncs(const ReadData& rd, const list<Item>& lst, ::strea
 		RedTestCfgStart();  break;
 	case REDTESTCFGSTOP:
 		RedTestCfgStop();  break;
-	//case FIXPOINTDAOADD:
-	//	FixPointDaoAdd(lst);  break;
-	//case FIXPOINTDAODEL: 
-	//	FixPointDaoDel(lst);  break;
 	default:
 		break;
 	}
-
+	
+}
+
+
+void ConfigManager::ScanerCtrlCfgReq(const ReadData& rd, const list<Item>& lst, ::stream::ResponseAny** response) {
+
+	stream::ScannerCrtlCfgResp result;
+	auto start = m_ScannerControlCfgDao->m_ScannerControlCfgMap.begin();
+	while(start != m_ScannerControlCfgDao->m_ScannerControlCfgMap.end()) {
+		::stream::ScannerCrtlCfgData* sccfg = result.add_scannercfg();
+		start->second->SetScannerCtrlCfg(sccfg);
+
+		auto fpitem = start->second->m_FixPointWrapper.m_Cfgs.begin();
+		while (fpitem != start->second->m_FixPointWrapper.m_Cfgs.end()) {
+			(*fpitem)->SetFixPointCfg(sccfg->add_fixpointdata());
+			++fpitem;
+		}
+
+		start->second->m_ScanCfgWrapper.m_ScanParamCfg.SetScanParam(sccfg->mutable_scanparamcfg());
+		start->second->m_ScanCfgWrapper.m_HatchingParams.SetScanParam(sccfg->mutable_hatchingparams());
+		start->second->m_ScanCfgWrapper.m_BorderParams.SetScanParam(sccfg->mutable_borderparams());
+		start->second->m_ScanCfgWrapper.m_SupportParams.SetScanParam(sccfg->mutable_supportparams());
+		start->second->m_ScanCfgWrapper.m_CorrectParamCfg.SetCorrectCfg(sccfg->mutable_correctparamcfg());
+		start->second->m_ScanCfgWrapper.m_ScanTestCfg.SetScanTestCfg(sccfg->mutable_scantestcfg());
+		start->second->m_ScanCfgWrapper.m_SkyWritingCfg.SetSkyWritingCfg(sccfg->mutable_skywritingcfg());
+
+		auto pcs = start->second->m_ScanCfgWrapper.m_PowerCompensateCfg.m_pcs.begin();
+		while (pcs != start->second->m_ScanCfgWrapper.m_PowerCompensateCfg.m_pcs.end()) {
+			(*pcs)->SetPowerComp(sccfg->add_powercompensate());
+			++pcs;
+		}
+		
+		auto tpcs = start->second->m_ScanCfgWrapper.m_TimePowerCompensateCfg.m_TimePowerCompensates.begin();
+		while (tpcs != start->second->m_ScanCfgWrapper.m_TimePowerCompensateCfg.m_TimePowerCompensates.end()) {
+			(*tpcs)->SetTimePowerComp(sccfg->add_tpowercompensate());
+			++tpcs;
+		}
+
+		++start;
+	}
+	
+	(*response)->mutable_data()->PackFrom(result);
 }
 
 
-//void ConfigManager::FixPointDaoAdd(const list<Item>& lst) {
-//	int scannerIndex = -1;
-//	FixPointCfg* fpc = new FixPointCfg();
-//	for (auto it = lst.begin(); it != lst.end(); ++it) {
-//		if (it->nameKey == "index") scannerIndex = ConverType::TryToI(it->strValue);
-//		if (it->nameKey == "cno") fpc->m_Cno = ConverType::TryToI(it->strValue);
-//		if (it->nameKey == "pointX") fpc->m_PointX = ConverType::TryToF(it->strValue);
-//		if (it->nameKey == "pointY") fpc->m_PointY = ConverType::TryToF(it->strValue);
-//		if (it->nameKey == "duration") fpc->m_Duration = (unsigned int)ConverType::TryToI(it->strValue);
-//	}
-//	
-//	//if (GetFixPointDao()->Add(fpc)){
-//	//	(*m_UIController.m_ScannerCtrl->GetScanners())[scannerIndex]->GetConfig()->m_FixPointWrapper.m_Cfgs->push_back(fpc);
-//	//}
-//}
-//
-//void ConfigManager::FixPointDaoDel(const list<Item>& lst) {
-//
-//}
 
 void ConfigManager::SendAlarmCfg() {
 	list<Item> lst;
 	auto start = m_AlarmCfgWrapper->m_StopAlarmCfgMap.begin();
 	while (start != m_AlarmCfgWrapper->m_StopAlarmCfgMap.end()) {
-		lst.emplace_back(Item{ start->first,"",UNKNOW,(*start).second->m_Content, (*start).second->m_IsEnable,
+		lst.emplace_back(Item{ start->first,(*start).second->m_Content, (*start).second->m_IsEnable,
 			(*start).second->m_IsAlarm, (*start).second->m_IsShow });
 		++start;
 	}
@@ -576,7 +587,7 @@ void ConfigManager::SendAlarmCfg() {
 	lst.clear();
 	start = m_AlarmCfgWrapper->m_PauseAlarmCfgMap.begin();
 	while (start != m_AlarmCfgWrapper->m_PauseAlarmCfgMap.end()) {
-		lst.emplace_back(Item{ start->first,"",UNKNOW,(*start).second->m_Content, (*start).second->m_IsEnable,
+		lst.emplace_back(Item{ start->first,(*start).second->m_Content, (*start).second->m_IsEnable,
 			(*start).second->m_IsAlarm, (*start).second->m_IsShow });
 		++start;
 	}
@@ -585,7 +596,7 @@ void ConfigManager::SendAlarmCfg() {
 	lst.clear();
 	start = m_AlarmCfgWrapper->m_WarnAlarmCfgMap.begin();
 	while (start != m_AlarmCfgWrapper->m_WarnAlarmCfgMap.end()) {
-		lst.emplace_back(Item{ start->first,"",UNKNOW,(*start).second->m_Content, (*start).second->m_IsEnable,
+		lst.emplace_back(Item{ start->first,(*start).second->m_Content, (*start).second->m_IsEnable,
 			(*start).second->m_IsAlarm, (*start).second->m_IsShow });
 		++start;
 	}
@@ -602,14 +613,14 @@ void ConfigManager::SendPowderCfg() {
 	m_ParamSetCfg.GetPowderCfg(vec);
 	auto powderStart = vec.begin();
 	while (powderStart != vec.end()) {
-		lst.emplace_back(Item{ "","",UNKNOW,"", 0,0,0,
-			powderStart->start_layer,powderStart->end_layer,powderStart->powder });
+		lst.emplace_back(Item{powderStart->start_layer,powderStart->end_layer,powderStart->powder });
 		++powderStart;
 	}
 	ClientWrapper::Instance()->PushAllClient(WriteData(POWDERSETPARAM, lst));
 
 }
 
+
 void ConfigManager::UpdateCfg(const ReadData& rd) {
 
 	switch (rd.dataType)
@@ -666,9 +677,9 @@ void ConfigManager::UpdateCommunicationCfg(const ReadData& rd) {
 		printf("not find this [%s] param\n", rd.nameKey.data());
 	}
 
-
 }
 
+
 void ConfigManager::ControlRun(const list<Item>& its) {
 	bool enable = false;
 	string code;
@@ -678,7 +689,6 @@ void ConfigManager::ControlRun(const list<Item>& its) {
 		if (item->nameKey == "code") code = item->strValue;
 	}
 
-
 	CommunicationCfg* cCfg = nullptr;
 	if (m_pCommunicationCfgDao->GetCommunicationCfg()->find(code) != m_pCommunicationCfgDao->GetCommunicationCfg()->end()) {
 		cCfg = (*m_pCommunicationCfgDao->GetCommunicationCfg())[code];
diff --git a/PrintS/Config/ConfigManager.h b/PrintS/Config/ConfigManager.h
index a031b88..7e94421 100644
--- a/PrintS/Config/ConfigManager.h
+++ b/PrintS/Config/ConfigManager.h
@@ -106,7 +106,7 @@ public:
 	ParamSetCfg* GetParamSetCfg() { return &m_ParamSetCfg; }    //已传
 	//map<int, LaserCfg*>* GetLaserCfgMap() { return &m_pLaserCfgDao->m_LaserCfgMap; }
 	//vector<LaserCfg*>* GetLaserCfgs() { return &m_pLaserCfgDao->m_LaserCfgs; }
-	map<int,ScannerControlCfg*>* GetScannerControlCfg() { return &m_ScannerControlCfgDao->m_ScannerControlCfgMap; }    //传
+	map<int,ScannerControlCfg*>* GetScannerControlCfg() { return &m_ScannerControlCfgDao->m_ScannerControlCfgMap; }    //已传  ScanerCtrlCfgReq发送
 	vector<ScannerControlCfg*>* GetScannerControlCfgs() { return &m_ScannerControlCfgDao->m_ScannerControlCfgs; }  //不传
 	vector<ScannerControlCfg*>* GetMatchScannerControlCfg() { return &m_ScannerControlCfgDao->m_MatchCfg; }  //添加2个函数 已传
 	ScannerControlCfgDao* GetScannerControlCfgDao() { return m_ScannerControlCfgDao; }   //不用
@@ -137,6 +137,7 @@ public:
 	void SendCfgToClients();
 	void UpdateCfg(const ReadData& rd);
 	void CallFuncs(const ReadData& rd, const list<Item>& lst = list<Item>(), ::stream::ResponseAny** response = nullptr);
+	void ScanerCtrlCfgReq(const ReadData& rd, const list<Item>& lst, ::stream::ResponseAny** response);   //
 private:
 	ConfigManager(const ConfigManager&) {};
 	ConfigManager& operator=(const ConfigManager&) {};
diff --git a/PrintS/Config/bean/CorrectParamCfg.cpp b/PrintS/Config/bean/CorrectParamCfg.cpp
index fcccfb7..8f88cb4 100644
--- a/PrintS/Config/bean/CorrectParamCfg.cpp
+++ b/PrintS/Config/bean/CorrectParamCfg.cpp
@@ -1,4 +1,4 @@
-#include "CorrectParamCfg.h"
+#include "CorrectParamCfg.h"
 #include "ScanCfg.h"
 
 
@@ -41,8 +41,8 @@ CorrectParamCfg::CorrectParamCfg()
 	m_FactorK=1824.0;
 	m_IsCorrectFile3D = true;
 	//m_DownSkinStopTimes = 0;
-	m_IsDynamicFocus = true;		//�Ƿ�̬�۽�
-	m_DefocusRatio = 10.0;		//�뽹��
+	m_IsDynamicFocus = true;		//是否动态聚焦
+	m_DefocusRatio = 10.0;		//离焦比
 	m_DefocusRatioMin = 0.0;
 	m_DefocusRatioMax = 50.0;
 }
@@ -110,6 +110,40 @@ void CorrectParamCfg::GetUpdateSql(int cno,vector<string>& ups) {
 	ups.push_back(buffer);
 }
 
+void CorrectParamCfg::SetCorrectCfg(stream::CorrectParamCfg* cp) {
+	cp->set_xmeasuremin(m_xmeasure_min);
+	cp->set_xmeasuremax(m_xmeasure_max);
+	cp->set_ymeasuremin(m_ymeasure_min);
+	cp->set_ymeasuremax(m_ymeasure_max);
+	cp->set_xposfix(m_xposfix);
+	cp->set_yposfix(m_yposfix);
+
+	cp->set_scanangle(m_scan_angle);
+	cp->set_scananglemin(m_scan_angle_min);
+	cp->set_scananglemax(m_scan_angle_max);
+	cp->set_fixanglemax(m_fix_angle);
+	cp->set_fixanglemin(m_fix_angle_min);
+	cp->set_fixanglemax(m_fix_angle_max);
+
+	cp->set_xcorrect(m_xcorrect);
+	cp->set_ycorrect(m_ycorrect);
+	cp->set_xcorrectmin(m_xcorrect_min);
+	cp->set_xcorrectmax(m_xcorrect_max);
+	cp->set_ycorrectmin(m_ycorrect_min);
+	cp->set_ycorrectmax(m_ycorrect_max);
+
+	cp->set_realxoffset(m_realXOffset);
+	cp->set_realyoffset(m_realYOffset);
+	cp->set_factork(m_FactorK);
+	cp->set_iscorrectfile3d(m_IsCorrectFile3D);
+	cp->set_isdynamicfocus(m_IsDynamicFocus);
+
+	cp->set_defocusratio(m_DefocusRatio);
+	cp->set_defocusratiomin(m_DefocusRatioMin);
+	cp->set_defocusratiomax(m_DefocusRatioMax);
+
+}
+
 string CorrectParamCfg::CONFIG_NAME = "CorrectParamCfg";
 string CorrectParamCfg::FIELD_X_MEASURE_MIN = "XMeasureMin";
 string CorrectParamCfg::FIELD_X_MEASURE_MAX = "XMeasureMax";
diff --git a/PrintS/Config/bean/CorrectParamCfg.h b/PrintS/Config/bean/CorrectParamCfg.h
index 0852c9b..3864c56 100644
--- a/PrintS/Config/bean/CorrectParamCfg.h
+++ b/PrintS/Config/bean/CorrectParamCfg.h
@@ -1,6 +1,7 @@
-#pragma once
+#pragma once
 #include <string>
 #include <vector>
+#include "../protobuf/stream.pb.h"
 
 using namespace std;
 class CorrectParamCfg
@@ -9,40 +10,42 @@ public:
 	CorrectParamCfg();
 	~CorrectParamCfg();
 	void GetUpdateSql(int cno,vector<string>& ups);
+
+	void SetCorrectCfg(stream::CorrectParamCfg* cp);
 public:
-	double m_xmeasure_min;			//x�ɴ�ӡ��Сλ��
-	double m_xmeasure_max;			//x�ɴ�ӡ���λ��
-	double m_ymeasure_min;			//y�ɴ�ӡ��Сλ��
-	double m_ymeasure_max;			//y�ɴ�ӡ���λ��
-	double m_xposfix;				//x�����
-	double m_yposfix;				//y�����
-	//double m_xoffset;				//xλ��ƫ�� ������
-	//double m_yoffset;				//yλ��ƫ�� ������
-	double m_scan_angle;					//��ת�Ƕ�  ��ʱ��
+	double m_xmeasure_min;			//x可打印最小位置
+	double m_xmeasure_max;			//x可打印最大位置
+	double m_ymeasure_min;			//y可打印最小位置
+	double m_ymeasure_max;			//y可打印最大位置
+	double m_xposfix;				//x位置修正
+	double m_yposfix;				//y位置修正
+	//double m_xoffset;				//x位置偏移 不保存
+	//double m_yoffset;				//y位置偏移 不保存
+	double m_scan_angle;					//旋转角度  逆时针
 	double m_scan_angle_min;
 	double m_scan_angle_max;
-	double m_fix_angle;					//��ת�Ƕ�  ��ʱ��
+	double m_fix_angle;					//旋转角度  逆时针
 	double m_fix_angle_min;
 	double m_fix_angle_max;
-	double m_xcorrect;				//x�ߴ�����
-	double m_ycorrect;				//y�ߴ�����
+	double m_xcorrect;				//x尺寸修正
+	double m_ycorrect;				//y尺寸修正
 	double m_xcorrect_min;
 	double m_xcorrect_max;
 	double m_ycorrect_min;
 	double m_ycorrect_max;
-	//double m_xscale;				//x���ű��� ������
+	//double m_xscale;				//x缩放比例 不保存
 	//double m_xscale_min;
 	//double m_xscale_max;
-	//double m_yscale;				//y���ű��� ������
+	//double m_yscale;				//y缩放比例 不保存
 	//double m_yscale_min;
 	//double m_yscale_max;
 	double m_realXOffset;
 	double m_realYOffset;
 	double m_FactorK;
 	bool m_IsCorrectFile3D;
-	//unsigned int m_DownSkinStopTimes;  //�±���ֹͣ����
-	bool m_IsDynamicFocus;		//�Ƿ�̬�۽�
-	double m_DefocusRatio;		//�뽹��
+	//unsigned int m_DownSkinStopTimes;  //下表面停止次数
+	bool m_IsDynamicFocus;		//是否动态聚焦
+	double m_DefocusRatio;		//离焦比
 	double m_DefocusRatioMin;
 	double m_DefocusRatioMax;
 
diff --git a/PrintS/Config/bean/FixPointCfg.cpp b/PrintS/Config/bean/FixPointCfg.cpp
index 0f429d6..6047d79 100644
--- a/PrintS/Config/bean/FixPointCfg.cpp
+++ b/PrintS/Config/bean/FixPointCfg.cpp
@@ -1,4 +1,4 @@
-#include "FixPointCfg.h"
+#include "FixPointCfg.h"
 
 
 
@@ -19,6 +19,14 @@ string FixPointCfg::GetUpdateSql()
 	return buffer;
 }
 
+void FixPointCfg::SetFixPointCfg(stream::FixPointData* fp) {
+	fp->set_cno(m_Cno);
+	fp->set_duration(m_Duration);
+	fp->set_id(m_Id);
+	fp->set_pointx(m_PointX);
+	fp->set_pointy(m_PointY);
+}
+
 const string FixPointCfg::TABLE_NAME="FixPoints";
 const string FixPointCfg::FIELD_ID="Id";
 const string FixPointCfg::FIELD_CNO = "Cno";
diff --git a/PrintS/Config/bean/FixPointCfg.h b/PrintS/Config/bean/FixPointCfg.h
index 1d97823..7a406b6 100644
--- a/PrintS/Config/bean/FixPointCfg.h
+++ b/PrintS/Config/bean/FixPointCfg.h
@@ -1,8 +1,9 @@
-#pragma once
+#pragma once
 #include <windows.h>
 #include <string>
 #include <vector>
 #include <list>
+#include "../protobuf/stream.pb.h"
 
 using namespace std;
 class FixPointCfg
@@ -11,6 +12,7 @@ public:
 	FixPointCfg();
 	~FixPointCfg();
 	string GetUpdateSql();
+	void SetFixPointCfg(stream::FixPointData* sp);
 public:
 	int m_Id;
 	int m_Cno;
diff --git a/PrintS/Config/bean/PowerCompensate.cpp b/PrintS/Config/bean/PowerCompensate.cpp
index f832a78..2eff2c1 100644
--- a/PrintS/Config/bean/PowerCompensate.cpp
+++ b/PrintS/Config/bean/PowerCompensate.cpp
@@ -1,4 +1,4 @@
-#include "PowerCompensate.h"
+#include "PowerCompensate.h"
 
 
 
@@ -33,6 +33,15 @@ void PowerCompensate::Generate(int cno,vector<string>& ins)
 	}
 }
 
+void PowerCompensate::SetPowerComp(stream::PowerCompensate* cp) {
+	cp->set_cno(m_cno);
+	cp->set_percent(m_percent);
+	cp->set_value(m_value);
+	cp->set_value_min(m_value_min);
+	cp->set_value_max(m_value_max);
+
+}
+
 
 const string PowerCompensate::TABLE_NAME="PowerCompensate";
 const string PowerCompensate::FIELD_CNO = "cno";
diff --git a/PrintS/Config/bean/PowerCompensate.h b/PrintS/Config/bean/PowerCompensate.h
index f9ed3c3..44da056 100644
--- a/PrintS/Config/bean/PowerCompensate.h
+++ b/PrintS/Config/bean/PowerCompensate.h
@@ -1,6 +1,7 @@
-#pragma once
+#pragma once
 #include <string>
 #include <vector>
+#include "../protobuf/stream.pb.h"
 
 using namespace std;
 class PowerCompensate
@@ -9,6 +10,7 @@ public:
 	PowerCompensate();
 	~PowerCompensate();
 	static void Generate(int cno,vector<string>& ins);
+	void SetPowerComp(stream::PowerCompensate* cp);
 public:
 	int m_cno;
 	unsigned short m_percent;
diff --git a/PrintS/Config/bean/ScanParamCfg.cpp b/PrintS/Config/bean/ScanParamCfg.cpp
index 46595af..54530e2 100644
--- a/PrintS/Config/bean/ScanParamCfg.cpp
+++ b/PrintS/Config/bean/ScanParamCfg.cpp
@@ -1,4 +1,4 @@
-#include "ScanParamCfg.h"
+#include "ScanParamCfg.h"
 #include "ScanCfg.h"
 #include "../../utils/StringHelper.h"
 
@@ -92,6 +92,41 @@ void ScanParamCfg::GetUpdateSql(int cno,vector<string>& ups)
 }
 
 
+void ScanParamCfg::SetScanParam(stream::ScanParamCfg* sp) {
+	sp->set_edgelevel(m_edge_level);
+	sp->set_edgelevelmin( m_edge_level_min);
+	sp->set_edgelevelmax( m_edge_level_max);
+	sp->set_jumpdelay( m_jump_delay);
+	sp->set_jumpdelaymin( m_jump_delay_min);
+	sp->set_jumpdelaymax( m_jump_delay_max);
+	sp->set_scandelay( m_scan_delay);
+	sp->set_scandelaymin( m_scan_delay_min);
+	sp->set_scandelaymax( m_scan_delay_max);
+	sp->set_polygondelay( m_polygon_delay);
+	sp->set_polygondelaymin( m_polygon_delay_min);
+	sp->set_polygondelaymax( m_polygon_delay_max);
+	sp->set_laseroffdelay( m_laseroff_delay);
+	sp->set_laseroffdelaymin( m_laseroff_delay_min);
+	sp->set_laseroffdelaymax( m_laseroff_delay_max);
+	sp->set_laserondelay( m_laseron_delay);
+	sp->set_laserondelaymin( m_laseron_delay_min);
+	sp->set_laserondelaymax( m_laseron_delay_max);
+	sp->set_minjumpdelay( m_min_jump_delay);
+	sp->set_minjumpdelaymin( m_min_jump_delay_min);
+	sp->set_minjumpdelaymax( m_min_jump_delay_max);
+	sp->set_jumplengthlimit( m_jump_length_limit);
+	sp->set_jumplengthlimitmin( m_jump_length_limit_min);
+	sp->set_jumplengthlimitmax( m_jump_length_limit_max);
+	sp->set_jumpspeed( m_jump_speed);
+	sp->set_jumpspeedmin( m_jump_speed_min);
+	sp->set_jumpspeedmax( m_jump_speed_max);
+	sp->set_markspeed( m_mark_speed);
+	sp->set_markspeedmin( m_mark_speed_min);
+	sp->set_markspeedmax( m_polygon_delay_max);
+
+}
+
+
 //string ScanParamCfg::CONFIG_NAME = "ScanParamCfg";
 string ScanParamCfg::FIELD_EDGE_LEVEL = "EdgeLevel";
 string ScanParamCfg::FIELD_EDGE_LEVEL_MIN = "EdgeLevelMin";
diff --git a/PrintS/Config/bean/ScanParamCfg.h b/PrintS/Config/bean/ScanParamCfg.h
index e1af2f3..deec20a 100644
--- a/PrintS/Config/bean/ScanParamCfg.h
+++ b/PrintS/Config/bean/ScanParamCfg.h
@@ -1,6 +1,7 @@
-#pragma once
+#pragma once
 #include <string>
 #include <vector>
+#include "../protobuf/stream.pb.h"
 using namespace std;
 class ScanParamCfg
 {
@@ -9,6 +10,7 @@ public:
 	~ScanParamCfg();
 	void GetUpdateSql(int cno,vector<string>& ups);
 
+	void SetScanParam(stream::ScanParamCfg* sp);
 public:
 	string CONFIG_NAME;
 	static string FIELD_EDGE_LEVEL;
diff --git a/PrintS/Config/bean/ScanTestCfg.cpp b/PrintS/Config/bean/ScanTestCfg.cpp
index 4d92fea..a8b03c8 100644
--- a/PrintS/Config/bean/ScanTestCfg.cpp
+++ b/PrintS/Config/bean/ScanTestCfg.cpp
@@ -1,4 +1,4 @@
-#include "ScanTestCfg.h"
+#include "ScanTestCfg.h"
 #include "ScanCfg.h"
 #include "../../utils/StringHelper.h"
 
@@ -90,6 +90,35 @@ void ScanTestCfg::GetUpdateSql(int cno,vector<string>& ups)
 }
 
 
+void ScanTestCfg::SetScanTestCfg(stream::ScanTestCfg* cp) {
+	cp->set_debugshape(m_debug_shape);
+	cp->set_shapesize(m_shape_size);
+	cp->set_shapesizemin(m_shape_size_min);
+	cp->set_shape_size_max(m_shape_size_max);
+	cp->set_laser_power(m_laser_power);
+	cp->set_laser_power_min(m_laser_power_min);
+	cp->set_laser_power_max(m_laser_power_max);
+
+	cp->set_defocus(m_defocus);
+	cp->set_defocus_min(m_defocus_min);
+	cp->set_defocus_max(m_defocus_max);
+	cp->set_is_cycle(m_is_cycle);
+	cp->set_cross_x(m_cross_x);
+	cp->set_cross_y(m_cross_y);
+
+	cp->set_z_distance(m_z_distance);
+	cp->set_isautoheatingscanner(m_IsAutoHeatingScanner);
+	cp->set_autoheatingscannerminutes(m_AutoHeatingScannerMinutes);
+	cp->set_autoheatingscannersize(m_AutoHeatingScannerSize);
+	cp->set_autoheatingscannerspeed(m_AutoHeatingScannerSpeed);
+	
+	cp->set_mark_test_start_x(m_mark_test_start_x);
+	cp->set_mark_test_start_y(m_mark_test_start_y);
+	cp->set_mark_test_end_x(m_mark_test_end_x);
+	cp->set_mark_test_end_y(m_mark_test_end_y);
+
+}
+
 string ScanTestCfg::CONFIG_NAME="ScanTest";
 string ScanTestCfg::FIELD_DEBUG_SHAPE = "DebugShape";
 string ScanTestCfg::FIELD_SHAPE_SIZE = "ShapeSize";
diff --git a/PrintS/Config/bean/ScanTestCfg.h b/PrintS/Config/bean/ScanTestCfg.h
index a8bc172..9915ab0 100644
--- a/PrintS/Config/bean/ScanTestCfg.h
+++ b/PrintS/Config/bean/ScanTestCfg.h
@@ -1,6 +1,7 @@
-#pragma once
+#pragma once
 #include <string>
 #include <vector>
+#include "../protobuf/stream.pb.h"
 
 using namespace std;
 class ScanTestCfg
@@ -10,6 +11,7 @@ public:
 	~ScanTestCfg();
 	void GetUpdateSql(int cno,vector<string>& ups);
 
+	void SetScanTestCfg(stream::ScanTestCfg* cp);
 public:
 	int m_debug_shape;
 	int m_shape_size;
@@ -27,7 +29,7 @@ public:
 
 	double m_z_distance;
 
-	bool m_IsAutoHeatingScanner;		//������ͣ��ʼʱԤ����
+	bool m_IsAutoHeatingScanner;		//开启暂停开始时预热振镜
 	unsigned int m_AutoHeatingScannerMinutes;
 	unsigned int m_AutoHeatingScannerSize;
 	double m_AutoHeatingScannerSpeed;
diff --git a/PrintS/Config/bean/ScannerControlCfg.cpp b/PrintS/Config/bean/ScannerControlCfg.cpp
index f1ce230..31fecc9 100644
--- a/PrintS/Config/bean/ScannerControlCfg.cpp
+++ b/PrintS/Config/bean/ScannerControlCfg.cpp
@@ -3,8 +3,8 @@
 
 
 ScannerControlCfg::ScannerControlCfg()
-	: /*m_Index(new IntData("Index"))
-	,*/ m_SeqNo(new IntData("SeqNo"))
+	/*: m_Index(new IntData("Index"))
+	, m_SeqNo(new IntData("SeqNo"))
 	, m_ControlNo(new IntData("ControlNo"))
 	, m_SerialNo(new IntData("SerialNo"))
 	, m_ControlType(new IntData("ControlType"))
@@ -12,7 +12,7 @@ ScannerControlCfg::ScannerControlCfg()
 	, m_CardIP(new StrData("CardIP"))
 	, m_IsEnable(new BoolData("IsEnable"))
 	, m_HadAssign(new BoolData("HadAssign"))
-	, m_HadMatch(new BoolData("HadMatch"))
+	, m_HadMatch(new BoolData("HadMatch"))*/
 {
 }
 
@@ -40,9 +40,9 @@ string ScannerControlCfg::GetUpdateSql()
 	string sql = "UPDATE %s SET %s=%d,%s=%d WHERE %s=%d";
 	sprintf_s(buffer, sizeof(buffer), "UPDATE %s SET %s=%d,%s=%d WHERE %s=%d", 
 		TABLE_NAME.c_str(),
-		FIELD_CONTROL_NO.c_str(), m_ControlNo->GetValue(),
-		FIELD_SERIAL_NO.c_str(), m_SerialNo->GetValue(),
-		FIELD_SEQ_NO.c_str(),m_SeqNo->GetValue());
+		FIELD_CONTROL_NO.c_str(), m_ControlNo ,
+		FIELD_SERIAL_NO.c_str(), m_SerialNo ,
+		FIELD_SEQ_NO.c_str(),m_SeqNo );
 
 	return buffer;
 }
@@ -58,6 +58,18 @@ ScanParamCfg* ScannerControlCfg::GetScanParamCfg(string str)
 	}
 }
 
+void ScannerControlCfg::SetScannerCtrlCfg(stream::ScannerCrtlCfgData* sccd) {
+	sccd->set_seqno(m_SeqNo);
+	sccd->set_controlno(m_ControlNo);
+	sccd->set_serialno(m_SerialNo);
+	sccd->set_controltype(m_ControlType);
+	sccd->set_cardname(m_CardName);
+	sccd->set_cardip(m_CardIP);
+	sccd->set_isenable(m_IsEnable);
+	sccd->set_hadassign(m_HadAssign);
+	sccd->set_hadmatch(m_HadMatch);
+}
+
 const string ScannerControlCfg::TABLE_NAME="ScannerControlCfg";
 const string ScannerControlCfg::FIELD_SEQ_NO="SeqNo";
 const string ScannerControlCfg::FIELD_CONTROL_NO="ControlNo";
diff --git a/PrintS/Config/bean/ScannerControlCfg.h b/PrintS/Config/bean/ScannerControlCfg.h
index 39e2c08..0dc5700 100644
--- a/PrintS/Config/bean/ScannerControlCfg.h
+++ b/PrintS/Config/bean/ScannerControlCfg.h
@@ -6,6 +6,8 @@
 #include "FixPointCfg.h"
 #include "IOCfg.h"
 #include "../Controller/Base.h"
+#include "../protobuf/stream.pb.h"
+
 using namespace std;
 
 struct CardSerialPair {
@@ -23,21 +25,22 @@ public:
 	string GetUpdateSql();
 	void Init();
 	ScanParamCfg* GetScanParamCfg(string str);
+
+	void SetScannerCtrlCfg(stream::ScannerCrtlCfgData* );
 public:
 	//IntData* m_Index;  
-	IntData* m_SeqNo;   //编号 配合ConfigManager中的map
-	IntData* m_ControlNo;
-	IntData* m_SerialNo;
-	IntData* m_ControlType;
-	StrData* m_CardName;
-	StrData* m_CardIP;
-	BoolData* m_IsEnable;				//是否启动
-	BoolData* m_HadAssign;
-	BoolData* m_HadMatch;
-	
+	int m_SeqNo;   //编号 ConfigManager中的m_ScannerControlCfgMap的key
+	int m_ControlNo;
+	int m_SerialNo;
+	int m_ControlType;
+	string m_CardName;
+	string m_CardIP;
+	bool m_IsEnable;				//是否启动
+	bool m_HadAssign;
+	bool m_HadMatch;
 	
 	ScanCfgWrapper m_ScanCfgWrapper;
-	FixPointWrapper m_FixPointWrapper;
+	FixPointWrapper m_FixPointWrapper;   //添加一个函数，不传
 
 	IOCfg* m_LaserRed;  //不传了
 	IOCfg* m_LaserEnable;  //不传了
diff --git a/PrintS/Config/bean/SkyWritingCfg.cpp b/PrintS/Config/bean/SkyWritingCfg.cpp
index e01a2b7..f03691d 100644
--- a/PrintS/Config/bean/SkyWritingCfg.cpp
+++ b/PrintS/Config/bean/SkyWritingCfg.cpp
@@ -1,4 +1,4 @@
-#include "SkyWritingCfg.h"
+#include "SkyWritingCfg.h"
 #include "ScanCfg.h"
 
 
@@ -65,6 +65,28 @@ void SkyWritingCfg::GetUpdateSql(int cno,vector<string>& ups)
 	ups.push_back(buffer);
 }
 
+
+
+void SkyWritingCfg::SetSkyWritingCfg(stream::SkyWritingCfg * cp) {
+	cp->set_isenable(m_IsEnable);
+	cp->set_timelag(m_Timelag);
+	cp->set_timelagmin(m_TimelagMin);
+	cp->set_timelagmax(m_TimelagMax);
+	cp->set_laseronshift(m_LaserOnShift);
+	cp->set_laseronshiftmin(m_LaserOnShiftMin);
+	cp->set_laseronshiftmax(m_LaserOnShiftMax);
+	cp->set_nprev(m_Nprev);
+	cp->set_nprevmin(m_NprevMin);
+	cp->set_nprevmax(m_NprevMax);
+	cp->set_npost(m_Npost);
+	cp->set_npostmin(m_NpostMin);
+	cp->set_npostmax(m_NpostMax);
+	cp->set_mode(m_Mode);
+	cp->set_limite(m_Limite);
+	cp->set_limitemin(m_LimiteMin);
+	cp->set_limitemax(m_LimiteMax);
+}
+
 string SkyWritingCfg::CONFIG_NAME = "SkyWriting";
 string SkyWritingCfg::FIELD_IS_ENABLE = "is_enable";
 string SkyWritingCfg::FIELD_TIMELAG = "timelag";
diff --git a/PrintS/Config/bean/SkyWritingCfg.h b/PrintS/Config/bean/SkyWritingCfg.h
index 08e0ab8..b361fbc 100644
--- a/PrintS/Config/bean/SkyWritingCfg.h
+++ b/PrintS/Config/bean/SkyWritingCfg.h
@@ -1,6 +1,7 @@
-#pragma once
+#pragma once
 #include <string>
 #include <vector>
+#include "../protobuf/stream.pb.h"
 
 using namespace std;
 
@@ -10,7 +11,7 @@ public:
 	SkyWritingCfg();
 	~SkyWritingCfg();
 	void GetUpdateSql(int cno,vector<string>& ups);
-
+	void SetSkyWritingCfg(stream::SkyWritingCfg* cp);
 public:
 	bool m_IsEnable;
 	double m_Timelag;
diff --git a/PrintS/Config/bean/TimePowerCompensate.cpp b/PrintS/Config/bean/TimePowerCompensate.cpp
index 1f98e52..27973ae 100644
--- a/PrintS/Config/bean/TimePowerCompensate.cpp
+++ b/PrintS/Config/bean/TimePowerCompensate.cpp
@@ -1,4 +1,4 @@
-#include "TimePowerCompensate.h"
+#include "TimePowerCompensate.h"
 
 
 
@@ -13,6 +13,13 @@ TimePowerCompensate::~TimePowerCompensate()
 	
 }
 
+void TimePowerCompensate::SetTimePowerComp(stream::TimePowerCompensate* tpc) {
+	tpc->set_id(m_ID);
+	tpc->set_cno(m_Cno);
+	tpc->set_startminute(m_StartMinute);
+	tpc->set_endminute(m_EndMinute);
+	tpc->set_compensate(m_Compensate);
+}
 
 const string TimePowerCompensate::TABLE_NAME="TimePowerCompensate";
 const string TimePowerCompensate::FIELD_ID="id";
diff --git a/PrintS/Config/bean/TimePowerCompensate.h b/PrintS/Config/bean/TimePowerCompensate.h
index eac7918..653d0d5 100644
--- a/PrintS/Config/bean/TimePowerCompensate.h
+++ b/PrintS/Config/bean/TimePowerCompensate.h
@@ -1,7 +1,8 @@
-#pragma once
+#pragma once
 #include <string>
 #include <windows.h>
 #include <Vector>
+#include "../protobuf/stream.pb.h"
 using namespace std;
 
 class TimePowerCompensate
@@ -9,7 +10,7 @@ class TimePowerCompensate
 public:
 	TimePowerCompensate();
 	~TimePowerCompensate();
-
+	void SetTimePowerComp(stream::TimePowerCompensate* cp);
 public:
 	int m_ID;
 	int m_Cno;
diff --git a/PrintS/Config/dao/ScannerControlCfgDao.cpp b/PrintS/Config/dao/ScannerControlCfgDao.cpp
index 71aed4c..7e2df53 100644
--- a/PrintS/Config/dao/ScannerControlCfgDao.cpp
+++ b/PrintS/Config/dao/ScannerControlCfgDao.cpp
@@ -54,10 +54,10 @@ void ScannerControlCfgDao::Save()
 		ScannerControlCfg* pcfg = m_MatchCfg[i];
 		if (pcfg == NULL)continue;
 		m_pDB->exec(pcfg->GetUpdateSql());
-		m_ScanCfgDao->Save(pcfg->m_SeqNo->GetValue(), pcfg->m_ScanCfgWrapper);
-		m_PowerCompensateDao->Save(pcfg->m_SeqNo->GetValue(), pcfg->m_ScanCfgWrapper.m_PowerCompensateCfg);
-		m_TimePowerCompensateDao->Save(pcfg->m_SeqNo->GetValue(), pcfg->m_ScanCfgWrapper.m_TimePowerCompensateCfg);
-		m_FixPointDao->Save(pcfg->m_SeqNo->GetValue(), pcfg->m_FixPointWrapper);
+		m_ScanCfgDao->Save(pcfg->m_SeqNo , pcfg->m_ScanCfgWrapper);
+		m_PowerCompensateDao->Save(pcfg->m_SeqNo , pcfg->m_ScanCfgWrapper.m_PowerCompensateCfg);
+		m_TimePowerCompensateDao->Save(pcfg->m_SeqNo , pcfg->m_ScanCfgWrapper.m_TimePowerCompensateCfg);
+		m_FixPointDao->Save(pcfg->m_SeqNo , pcfg->m_FixPointWrapper);
 	}
 }
 
@@ -68,22 +68,22 @@ void ScannerControlCfgDao::FindCfg() {
 	{
 		ScannerControlCfg* cfg = m_ScannerControlCfgs[i];
 		//machine->InitScanParamBeforeFind(&cfg->m_ScanCfgWrapper);
-		m_ScanCfgDao->Find(cfg->m_SeqNo->GetValue(), cfg->m_ScanCfgWrapper);
-		m_PowerCompensateDao->Find(cfg->m_SeqNo->GetValue(), cfg->m_ScanCfgWrapper.m_PowerCompensateCfg);
+		m_ScanCfgDao->Find(cfg->m_SeqNo , cfg->m_ScanCfgWrapper);
+		m_PowerCompensateDao->Find(cfg->m_SeqNo , cfg->m_ScanCfgWrapper.m_PowerCompensateCfg);
 		if (cfg->m_ScanCfgWrapper.m_PowerCompensateCfg.m_pcs.empty()) {
 			for (int pcIndex = 5; pcIndex <= 100; pcIndex += 5) {
 				PowerCompensate* pc = new PowerCompensate();
-				pc->m_cno = cfg->m_SeqNo->GetValue();
+				pc->m_cno = cfg->m_SeqNo ;
 				pc->m_percent = pcIndex;
 				pc->m_value = 1.0f;
 				pc->m_value_min = 0.0f;
 				pc->m_value_max = 3.0f;
 				cfg->m_ScanCfgWrapper.m_PowerCompensateCfg.m_pcs.push_back(pc);
-				m_PowerCompensateDao->Add(cfg->m_SeqNo->GetValue(), pc);
+				m_PowerCompensateDao->Add(cfg->m_SeqNo , pc);
 			}
 		}
-		m_TimePowerCompensateDao->Find(cfg->m_SeqNo->GetValue(), cfg->m_ScanCfgWrapper.m_TimePowerCompensateCfg);
-		m_FixPointDao->Find(cfg->m_SeqNo->GetValue(), cfg->m_FixPointWrapper);
+		m_TimePowerCompensateDao->Find(cfg->m_SeqNo , cfg->m_ScanCfgWrapper.m_TimePowerCompensateCfg);
+		m_FixPointDao->Find(cfg->m_SeqNo , cfg->m_FixPointWrapper);
 	}
 }
 
@@ -95,15 +95,15 @@ void ScannerControlCfgDao::FindMain()
 	SQLite::Statement query(*m_pDB, buffer);
 	while (query.executeStep()) {
 		ScannerControlCfg* cfg = new ScannerControlCfg();
-		cfg->m_SeqNo ->SetValue(query.getColumn(ScannerControlCfg::FIELD_SEQ_NO.c_str()).getInt());
-		cfg->m_ControlNo->SetValue(query.getColumn(ScannerControlCfg::FIELD_CONTROL_NO.c_str()).getInt());
-		cfg->m_SerialNo->SetValue(query.getColumn(ScannerControlCfg::FIELD_SERIAL_NO.c_str()).getInt());
-		cfg->m_ControlType->SetValue(query.getColumn(ScannerControlCfg::FIELD_CONTROL_TYPE.c_str()).getInt());
-		cfg->m_CardName->SetValue(query.getColumn(ScannerControlCfg::FIELD_CARD_NAME.c_str()).getString());
-		cfg->m_CardIP->SetValue(query.getColumn(ScannerControlCfg::FIELD_CARD_IP.c_str()).getString());
-		cfg->m_IsEnable->SetValue(query.getColumn(ScannerControlCfg::FIELD_IS_ENABLE.c_str()).getInt() > 0 ? true : false);
+		cfg->m_SeqNo=query.getColumn(ScannerControlCfg::FIELD_SEQ_NO.c_str()).getInt();
+		cfg->m_ControlNo =query.getColumn(ScannerControlCfg::FIELD_CONTROL_NO.c_str()).getInt();
+		cfg->m_SerialNo =query.getColumn(ScannerControlCfg::FIELD_SERIAL_NO.c_str()).getInt();
+		cfg->m_ControlType =query.getColumn(ScannerControlCfg::FIELD_CONTROL_TYPE.c_str()).getInt();
+		cfg->m_CardName =query.getColumn(ScannerControlCfg::FIELD_CARD_NAME.c_str()).getString();
+		cfg->m_CardIP =query.getColumn(ScannerControlCfg::FIELD_CARD_IP.c_str()).getString();
+		cfg->m_IsEnable =query.getColumn(ScannerControlCfg::FIELD_IS_ENABLE.c_str()).getInt() > 0 ? true : false;
 		m_ScannerControlCfgs.push_back(cfg);
-		m_ScannerControlCfgMap[cfg->m_SeqNo->GetValue()] = cfg;
+		m_ScannerControlCfgMap[cfg->m_SeqNo ] = cfg;
 	}
 }
 
@@ -113,9 +113,9 @@ void ScannerControlCfgDao::Export(stringstream& ss)
 		ScannerControlCfg* pcfg = m_MatchCfg[i];
 		if (pcfg == NULL)continue;
 		ss << pcfg->GetUpdateSql() << "\n";
-		m_ScanCfgDao->Export(pcfg->m_SeqNo->GetValue(), pcfg->m_ScanCfgWrapper, ss);
-		m_PowerCompensateDao->Export(pcfg->m_SeqNo->GetValue(), pcfg->m_ScanCfgWrapper.m_PowerCompensateCfg, ss);
-		m_TimePowerCompensateDao->Export(pcfg->m_SeqNo->GetValue(), pcfg->m_ScanCfgWrapper.m_TimePowerCompensateCfg, ss);
+		m_ScanCfgDao->Export(pcfg->m_SeqNo , pcfg->m_ScanCfgWrapper, ss);
+		m_PowerCompensateDao->Export(pcfg->m_SeqNo , pcfg->m_ScanCfgWrapper.m_PowerCompensateCfg, ss);
+		m_TimePowerCompensateDao->Export(pcfg->m_SeqNo , pcfg->m_ScanCfgWrapper.m_TimePowerCompensateCfg, ss);
 	}
 }
 
@@ -123,7 +123,7 @@ void ScannerControlCfgDao::ExportAllPC(stringstream& ss)
 {
 	for (size_t i = 0; i < m_MatchCfg.size(); ++i) {
 		ScannerControlCfg* pcfg = m_MatchCfg[i];
-		m_PowerCompensateDao->Export(pcfg->m_SeqNo->GetValue(), pcfg->m_ScanCfgWrapper.m_PowerCompensateCfg, ss);
+		m_PowerCompensateDao->Export(pcfg->m_SeqNo , pcfg->m_ScanCfgWrapper.m_PowerCompensateCfg, ss);
 	}
 }
 
@@ -140,7 +140,7 @@ void ScannerControlCfgDao::ImportAllPc(std::string &sql)
 
 	for (size_t i = 0; i < m_ScannerControlCfgs.size(); ++i) {
 		ScannerControlCfg* pcfg = m_ScannerControlCfgMap[i];
-		m_PowerCompensateDao->Find(pcfg->m_SeqNo->GetValue(), pcfg->m_ScanCfgWrapper.m_PowerCompensateCfg);
+		m_PowerCompensateDao->Find(pcfg->m_SeqNo , pcfg->m_ScanCfgWrapper.m_PowerCompensateCfg);
 	}
 }
 
@@ -157,7 +157,7 @@ void ScannerControlCfgDao::Add(ScannerControlCfg* cfg)
 		ScannerControlCfg::FIELD_CARD_NAME.c_str(),
 		ScannerControlCfg::FIELD_CARD_IP.c_str(),
 		ScannerControlCfg::FIELD_IS_ENABLE.c_str(),
-		cfg->m_SeqNo->GetValue(), cfg->m_ControlNo->GetValue(), cfg->m_SerialNo->GetValue(), cfg->m_ControlType->GetValue(), cfg->m_CardName->GetValueStr().c_str(), "", cfg->m_IsEnable->GetValue() ? 1 : 0);
+		cfg->m_SeqNo , cfg->m_ControlNo , cfg->m_SerialNo , cfg->m_ControlType , cfg->m_CardName.c_str(), "", cfg->m_IsEnable  ? 1 : 0);
 	m_pDB->exec(buffer);
 }
 
@@ -168,7 +168,7 @@ void ScannerControlCfgDao::Delete(int seq)
 	m_pDB->exec(buffer);
 
 	for (vector<ScannerControlCfg*>::iterator it = m_ScannerControlCfgs.begin(); it != m_ScannerControlCfgs.end();) {
-		if ((*it)->m_SeqNo->GetValue() == seq)
+		if ((*it)->m_SeqNo  == seq)
 		{
 			it = m_ScannerControlCfgs.erase(it);
 			break;
@@ -179,7 +179,7 @@ void ScannerControlCfgDao::Delete(int seq)
 	}
 
 	for (vector<ScannerControlCfg*>::iterator it = m_MatchCfg.begin(); it != m_MatchCfg.end();) {
-		if ((*it)->m_SeqNo->GetValue() == seq)
+		if ((*it)->m_SeqNo  == seq)
 		{
 			it = m_MatchCfg.erase(it);
 			break;
@@ -204,20 +204,20 @@ void ScannerControlCfgDao::Delete(int seq)
 
 void ScannerControlCfgDao::Maintain(ScannerControlCfg* cfg)
 {
-	m_ScanCfgDao->Find(cfg->m_SeqNo->GetValue(), cfg->m_ScanCfgWrapper);
-	m_PowerCompensateDao->Find(cfg->m_SeqNo->GetValue(), cfg->m_ScanCfgWrapper.m_PowerCompensateCfg);
+	m_ScanCfgDao->Find(cfg->m_SeqNo , cfg->m_ScanCfgWrapper);
+	m_PowerCompensateDao->Find(cfg->m_SeqNo , cfg->m_ScanCfgWrapper.m_PowerCompensateCfg);
 	if (cfg->m_ScanCfgWrapper.m_PowerCompensateCfg.m_pcs.empty()) {
 		for (int pcIndex = 5; pcIndex <= 100; pcIndex += 5) {
 			PowerCompensate* pc = new PowerCompensate();
-			pc->m_cno = cfg->m_SeqNo->GetValue();
+			pc->m_cno = cfg->m_SeqNo ;
 			pc->m_percent = pcIndex;
 			pc->m_value = 1.0f;
 			pc->m_value_min = 0.0f;
 			pc->m_value_max = 3.0f;
 			cfg->m_ScanCfgWrapper.m_PowerCompensateCfg.m_pcs.push_back(pc);
-			m_PowerCompensateDao->Add(cfg->m_SeqNo->GetValue(), pc);
+			m_PowerCompensateDao->Add(cfg->m_SeqNo , pc);
 		}
 	}
-	m_TimePowerCompensateDao->Find(cfg->m_SeqNo->GetValue(), cfg->m_ScanCfgWrapper.m_TimePowerCompensateCfg);
-	m_FixPointDao->Find(cfg->m_SeqNo->GetValue(), cfg->m_FixPointWrapper);
+	m_TimePowerCompensateDao->Find(cfg->m_SeqNo , cfg->m_ScanCfgWrapper.m_TimePowerCompensateCfg);
+	m_FixPointDao->Find(cfg->m_SeqNo , cfg->m_FixPointWrapper);
 }
\ No newline at end of file
diff --git a/PrintS/DataManage/DataHandle.cpp b/PrintS/DataManage/DataHandle.cpp
index 8252e8d..1518e2a 100644
--- a/PrintS/DataManage/DataHandle.cpp
+++ b/PrintS/DataManage/DataHandle.cpp
@@ -29,6 +29,9 @@ void DataHandle::FuncDataCallBackProc(void* pthis,const ReadData& msg, const lis
 	else if ((READTYPE)msg.dataType == CONFIGFUNC) {
 		p->m_config->CallFuncs(msg, lst, response);
 	}
+	else if ((READTYPE)msg.dataType == SCANERCTRLCFG) {
+		p->m_config->ScanerCtrlCfgReq(msg, lst, response);
+	}
 
 }
 
diff --git a/PrintS/DataManage/RWData.h b/PrintS/DataManage/RWData.h
index e1cb071..5aed65e 100644
--- a/PrintS/DataManage/RWData.h
+++ b/PrintS/DataManage/RWData.h
@@ -35,6 +35,7 @@ enum READTYPE {
     COMMUNICATIONCFG,
     ALARMCFG,
     POWDERSET,
+    SCANERCTRLCFG,
 
     LOADPARAM,  //装载参数
 
@@ -118,6 +119,7 @@ enum WRITETYPE {
     PAUSEALARMCFGPARAM,     //AlarmCfgWrapper pause参数
     WARNALARMCFGPARAM,     //AlarmCfgWrapper warn参数
     POWDERSETPARAM,    //PowderSet 参数
+    //SCANNERCONTROLCFGPARAM,    //ScannerControlCfg 参数
 
     MOLDCFGPARAM,
     LOADCFGPARAM,
@@ -138,31 +140,42 @@ enum WRITETYPE {
 };
 
 struct Item {
+    Item() {}
+
     std::string nameKey;   //参数key
     std::string  strValue;    //value
     DATATYPE  valueType;  //数据类型
+    Item(const std::string& nameKey,const std::string& strValue, DATATYPE  valueType)
+        :nameKey(nameKey), strValue(strValue), valueType(valueType) {}
 
     std::string content;     //alarmcfgwrapper使用
     bool isEnable;   
     bool isAlarm;    
     bool isShow;     
+    Item(const std::string& nameKey, const std::string& content, bool  isEnable, bool isAlarm, bool isShow)
+        :nameKey(nameKey), content(content), isEnable(isEnable), isAlarm(isAlarm), isShow(isShow){}
 
     //层供粉量配置使用  struct PowderSet
     int start_layer;
     int end_layer;
     float powder;
+    Item(int start_layer,int end_layer,float powder) :start_layer(start_layer), end_layer(end_layer), powder(powder){}
 
     //
-    //IntData* m_Index;   //编号 配合ConfigManager中的map
-    //IntData* m_SeqNo;
-    //IntData* m_ControlNo;
-    //IntData* m_SerialNo;
-    //IntData* m_ControlType;
-    //StrData* m_CardName;
-    //StrData* m_CardIP;
-    //BoolData* m_IsEnable;				//是否启动
-    //BoolData* m_HadAssign;
-    //BoolData* m_HadMatch;
+    int seqNo;   //ScannerControlCfg使用
+    int controlNo;
+    int serialNo;
+    int controlType;
+    std::string cardName;
+    std::string cardIP;
+    //bool isEnable;				//是否启动
+    bool hadAssign;
+    bool hadMatch;
+    Item(int seqNo, int controlNo, int serialNo, int controlType,const std::string& cardName,const std::string& cardIP, bool isEnable, bool hadAssign, bool hadMatch)
+    :seqNo(seqNo), controlNo(controlNo), serialNo(serialNo), controlType(controlType),
+        cardName(cardName), cardIP(cardIP), isEnable(isEnable), hadAssign(hadAssign), hadMatch(hadMatch) {
+    
+    }
 };
 
 class ClientInfo;
diff --git a/PrintS/DataManage/StreamServer.cpp b/PrintS/DataManage/StreamServer.cpp
index d1efe88..7e16107 100644
--- a/PrintS/DataManage/StreamServer.cpp
+++ b/PrintS/DataManage/StreamServer.cpp
@@ -64,8 +64,26 @@ Status StreamServer::AllStream(ServerContext* context, grpc::ServerReaderWriter<
             //函数参数
             std::list<Item> paramLst;  //
             for (const ::stream::ParamInfo it : request.item()) {
-                paramLst.emplace_back(Item{ it.namekey(),it.strvalue() ,(DATATYPE)it.valuetype()
-                    ,it.context(),it.isenable(),it.isalarm(),it.isshow(),it.startlayer(),it.endlayer(),it.powder()});  //直接加到readData.its上面，后续的请求无法收到，不知道为啥
+                Item temp{ it.namekey(),it.strvalue() ,(DATATYPE)it.valuetype() };
+
+                temp.content = it.context();
+                temp.isEnable = it.isenable();
+                temp.isAlarm = it.isalarm();
+                temp.isShow = it.isshow();
+
+                temp.start_layer = it.startlayer();
+                temp.end_layer = it.endlayer();
+                temp.powder = it.powder();
+                
+                temp.seqNo = it.seqno();
+                temp.controlNo = it.controlno();
+                temp.serialNo = it.serialno();
+                temp.controlType = it.controltype();
+                temp.cardName = it.cardname();
+                temp.cardIP = it.cardip();
+                temp.hadAssign = it.hadassign();
+                temp.hadMatch = it.hadmatch();
+                paramLst.emplace_back(std::move(temp));   //直接加到readData.its上面，后续的请求无法收到，不知道为啥
             }
 
             printf("客户端消息：dataType:%d,nameKey:%s, strValue:%s,valueType:%d,lst:%zd\n",
@@ -101,6 +119,16 @@ Status StreamServer::AllStream(ServerContext* context, grpc::ServerReaderWriter<
                     paramInfo->set_startlayer(wd->start_layer);
                     paramInfo->set_endlayer(wd->end_layer);
                     paramInfo->set_powder(wd->powder);
+
+                    paramInfo->set_seqno(wd->seqNo);
+                    paramInfo->set_controlno(wd->controlNo);
+                    paramInfo->set_serialno(wd->serialNo);
+                    paramInfo->set_controltype(wd->controlType);
+                    paramInfo->set_cardname(wd->cardName);
+                    paramInfo->set_cardip(wd->cardIP);
+                    paramInfo->set_isenable(wd->isEnable);
+                    paramInfo->set_hadassign(wd->hadAssign);
+                    paramInfo->set_hadmatch(wd->hadMatch);
                 }
                 stream->Write(response);
             }
diff --git a/PrintS/ScannerCtrl/RTC5Scanner.cpp b/PrintS/ScannerCtrl/RTC5Scanner.cpp
index 837850f..ab7c1f5 100644
--- a/PrintS/ScannerCtrl/RTC5Scanner.cpp
+++ b/PrintS/ScannerCtrl/RTC5Scanner.cpp
@@ -76,8 +76,8 @@ bool RTC5Scanner::Init()
 	//	m_SeqBit[i] = true;
 	//}
 
-	int controlNo = m_ScannerControlCfg->m_ControlNo->GetValue();
-	if ((m_ScannerControlCfg->m_SeqNo->GetValue() % 2) != 0) {
+	int controlNo = m_ScannerControlCfg->m_ControlNo ;
+	if ((m_ScannerControlCfg->m_SeqNo  % 2) != 0) {
 		m_IsLeftScan = true;
 	}
 	else {
@@ -104,7 +104,7 @@ bool RTC5Scanner::Init()
 		return false;
 	}
 	char buffer[512];
-	sprintf_s(buffer, sizeof(buffer), "%sSLM%d.ct5", g_AppPath.c_str(), m_ScannerControlCfg->m_SeqNo->GetValue());
+	sprintf_s(buffer, sizeof(buffer), "%sSLM%d.ct5", g_AppPath.c_str(), m_ScannerControlCfg->m_SeqNo );
 	string crtPath = string(buffer);
 	uint32_t dim = m_CorrectParamCfg->m_IsCorrectFile3D ? 3 : 2;
 	error = n_load_correction_file(controlNo, crtPath.c_str(), 1, dim);
@@ -195,7 +195,7 @@ void RTC5Scanner::LoadList(unsigned int listid, bool wait)
 {
 
 	if (wait) {
-		while (!n_load_list(m_ScannerControlCfg->m_ControlNo->GetValue(), listid, 0)) {
+		while (!n_load_list(m_ScannerControlCfg->m_ControlNo , listid, 0)) {
 			Sleep(20);
 			if (BaseCtrl::IsStop()) {
 				break;
@@ -203,28 +203,28 @@ void RTC5Scanner::LoadList(unsigned int listid, bool wait)
 		}
 	}
 	else {
-		n_load_list(m_ScannerControlCfg->m_ControlNo->GetValue(), listid, 0);
+		n_load_list(m_ScannerControlCfg->m_ControlNo , listid, 0);
 	}
 }
 
 void RTC5Scanner::EndList()
 {
-	n_set_end_of_list(m_ScannerControlCfg->m_ControlNo->GetValue());
+	n_set_end_of_list(m_ScannerControlCfg->m_ControlNo );
 }
 
 void RTC5Scanner::AutoChangeList() {
-	n_auto_change(m_ScannerControlCfg->m_ControlNo->GetValue());
+	n_auto_change(m_ScannerControlCfg->m_ControlNo );
 }
 
 void RTC5Scanner::ListExecute(unsigned int listid, bool wait)
 {
-	n_execute_list(m_ScannerControlCfg->m_ControlNo->GetValue(), listid);
+	n_execute_list(m_ScannerControlCfg->m_ControlNo , listid);
 	unsigned int Busy(0), Pos(0);
 	if (wait) {
 		do
 		{
 			Sleep(10);
-			n_get_status(m_ScannerControlCfg->m_ControlNo->GetValue(), Busy, Pos);
+			n_get_status(m_ScannerControlCfg->m_ControlNo , Busy, Pos);
 			if (BaseCtrl::IsStop()) {
 				break;
 			}
@@ -248,8 +248,8 @@ void RTC5Scanner::AddVector(double startx, double starty, double endx, double en
 	long lstarty = lround(bity1);
 	long lendx = lround(bitx2);
 	long lendy = lround(bity2);
-	n_jump_abs(m_ScannerControlCfg->m_ControlNo->GetValue(), lstartx, lstarty);
-	n_mark_abs(m_ScannerControlCfg->m_ControlNo->GetValue(), lendx, lendy);
+	n_jump_abs(m_ScannerControlCfg->m_ControlNo , lstartx, lstarty);
+	n_mark_abs(m_ScannerControlCfg->m_ControlNo , lendx, lendy);
 }
 
 
@@ -264,7 +264,7 @@ void RTC5Scanner::JumpAbs(double x, double y)
 
 	long lx = lround(bitx1);
 	long ly = lround(bity1);
-	n_jump_abs(m_ScannerControlCfg->m_ControlNo->GetValue(), lx, ly);
+	n_jump_abs(m_ScannerControlCfg->m_ControlNo , lx, ly);
 }
 
 void RTC5Scanner::MarkAbs(double x, double y)
@@ -278,7 +278,7 @@ void RTC5Scanner::MarkAbs(double x, double y)
 
 	long lx = lround(bitx1);
 	long ly = lround(bity1);
-	n_mark_abs(m_ScannerControlCfg->m_ControlNo->GetValue(), lx, ly);
+	n_mark_abs(m_ScannerControlCfg->m_ControlNo , lx, ly);
 }
 
 
@@ -288,7 +288,7 @@ void RTC5Scanner::WaitListFree()
 	do
 	{
 		Sleep(5);
-		n_get_status(m_ScannerControlCfg->m_ControlNo->GetValue(), Busy, Pos);
+		n_get_status(m_ScannerControlCfg->m_ControlNo , Busy, Pos);
 		if (BaseCtrl::IsStop()) {
 			break;
 		}
@@ -300,7 +300,7 @@ void RTC5Scanner::ScanDebug()
 {
 	SetAutoUpdateScanInfo(false);
 	Sleep(200);
-	int controlNo = m_ScannerControlCfg->m_ControlNo->GetValue();
+	int controlNo = m_ScannerControlCfg->m_ControlNo ;
 	unsigned int power = (unsigned int)(4095.0*m_PowerCompensateCfg->CalcPowerCompensate((float)m_ScanTestCfg->m_laser_power) / 100.0);
 	if (power > 4095)power = 4095;
 	double markspeed = m_kfactor*m_ScanParamCfg->m_mark_speed / 1000.0;
@@ -326,7 +326,7 @@ void RTC5Scanner::ScanDebug()
 
 void RTC5Scanner::ScanTestProc() {
 
-	int controlNo = m_ScannerControlCfg->m_ControlNo->GetValue();
+	int controlNo = m_ScannerControlCfg->m_ControlNo ;
 	int shapeSize = m_ScanTestCfg->m_shape_size;
 	switch (m_ScanTestCfg->m_debug_shape) {
 	case Cross: {
@@ -472,7 +472,7 @@ void RTC5Scanner::UpdateScanParamByCfg(ScanParamCfg* cfg)
 	unsigned int minJumpDelay = cfg->m_min_jump_delay / 10;
 	double jumpspeed = m_kfactor* cfg->m_jump_speed / 1000.0;
 
-	int controlNo = m_ScannerControlCfg->m_ControlNo->GetValue();
+	int controlNo = m_ScannerControlCfg->m_ControlNo ;
 	n_set_scanner_delays(controlNo, jumpDelay, markDelay, polygonDelay);
 	n_set_laser_delays(controlNo, laserOnDealy, laserOffDelay);
 	n_set_delay_mode_list(controlNo, 1, 1, edgeLevel, minJumpDelay, (unsigned int)(cfg->m_jump_length_limit*m_kfactor));
@@ -495,7 +495,7 @@ void RTC5Scanner::UpdateSetting()
 	unsigned int minJumpDelay = m_ScanParamCfg->m_min_jump_delay / 10;
 	unsigned int power = 4095.0* m_PowerCompensateCfg->CalcPowerCompensate((float)m_ScanTestCfg->m_laser_power) / 100.0;
 
-	int controlNo = m_ScannerControlCfg->m_ControlNo->GetValue();
+	int controlNo = m_ScannerControlCfg->m_ControlNo ;
 	double markspeed = m_kfactor*m_ScanParamCfg->m_mark_speed / 1000.0;
 	double jumpspeed = m_kfactor*m_ScanParamCfg->m_jump_speed / 1000.0;
 	n_write_da_x(controlNo, 1, power); //设置功率
@@ -515,19 +515,19 @@ void RTC5Scanner::UpdateSetting()
 void RTC5Scanner::SetScanSpeed(double fvalue)
 {
 	double speed = fvalue / 1000.0*m_kfactor;
-	n_set_mark_speed(m_ScannerControlCfg->m_ControlNo->GetValue(), speed);
+	n_set_mark_speed(m_ScannerControlCfg->m_ControlNo , speed);
 }
 
 void RTC5Scanner::SetPower(double watt)
 {
 	unsigned int power = 4095.0*watt / 100;
 	if (power > 4095)power = 4095;
-	n_write_da_1_list(m_ScannerControlCfg->m_ControlNo->GetValue(), power);
+	n_write_da_1_list(m_ScannerControlCfg->m_ControlNo , power);
 }
 
 bool RTC5Scanner::StopWork() {
 
-	n_stop_execution(m_ScannerControlCfg->m_ControlNo->GetValue());
+	n_stop_execution(m_ScannerControlCfg->m_ControlNo );
 
 	return true;
 }
@@ -548,7 +548,7 @@ void RTC5Scanner::UpdateSkyWriting(bool islist)
 	long laserOnShift = 0;
 	unsigned int nprev = 0;
 	unsigned int npost = 0;
-	int controlNo = m_ScannerControlCfg->m_ControlNo->GetValue();
+	int controlNo = m_ScannerControlCfg->m_ControlNo ;
 	switch (m_SkyWritingCfg->m_Mode)
 	{
 	case 1:
@@ -599,21 +599,21 @@ void RTC5Scanner::SetSkyWritingEnable(bool benable, bool islist)
 		UpdateSkyWriting(islist);
 	}
 	else {
-		if (islist) n_set_sky_writing_mode_list(m_ScannerControlCfg->m_ControlNo->GetValue(), 0);
-		else n_set_sky_writing_mode(m_ScannerControlCfg->m_ControlNo->GetValue(), 0);
+		if (islist) n_set_sky_writing_mode_list(m_ScannerControlCfg->m_ControlNo , 0);
+		else n_set_sky_writing_mode(m_ScannerControlCfg->m_ControlNo , 0);
 	}
 }
 
 void RTC5Scanner::SetDefocus(float value)
 {
 	long ds = value*m_zfactor;
-	n_set_defocus_list(m_ScannerControlCfg->m_ControlNo->GetValue(), ds);
+	n_set_defocus_list(m_ScannerControlCfg->m_ControlNo , ds);
 }
 
 
 void RTC5Scanner::ListNop() {
 	
-	n_list_nop(m_ScannerControlCfg->m_ControlNo->GetValue());
+	n_list_nop(m_ScannerControlCfg->m_ControlNo );
 	
 }
 
@@ -622,29 +622,29 @@ void RTC5Scanner::CheckAlarm()
 {
 	
 	if (!m_MachineCfg->m_IsIntelli->GetValue())return;
-	n_control_command(m_ScannerControlCfg->m_ControlNo->GetValue(), 1, 1, CurrentOperationStateLowAddr);
+	n_control_command(m_ScannerControlCfg->m_ControlNo , 1, 1, CurrentOperationStateLowAddr);
 	Sleep(2);
-	int xlowstate = n_get_value(m_ScannerControlCfg->m_ControlNo->GetValue(), 1);
+	int xlowstate = n_get_value(m_ScannerControlCfg->m_ControlNo , 1);
 	bool IsInternalVoltagesNormalX = (xlowstate & 0x20000) ? true : false;
 	bool IsCriticalErrorX = (xlowstate & 0x2000) ? false : true;
 	bool IsScannerAndServoBoradTempNormalX = (xlowstate & 0x8000) ? true : false;
 
-	n_control_command(m_ScannerControlCfg->m_ControlNo->GetValue(), 1, 2, CurrentOperationStateLowAddr);
+	n_control_command(m_ScannerControlCfg->m_ControlNo , 1, 2, CurrentOperationStateLowAddr);
 	Sleep(2);
-	int ylowstate = n_get_value(m_ScannerControlCfg->m_ControlNo->GetValue(), 2);
+	int ylowstate = n_get_value(m_ScannerControlCfg->m_ControlNo , 2);
 	bool IsInternalVoltagesNormalY = (ylowstate & 0x20000) ? true : false;
 	bool IsCriticalErrorY = (ylowstate & 0x2000) ? false : true;
 	bool IsScannerAndServoBoradTempNormalY = (ylowstate & 0x8000) ? true : false;
 
-	n_control_command(m_ScannerControlCfg->m_ControlNo->GetValue(), 1, 1, StopEventCode);
+	n_control_command(m_ScannerControlCfg->m_ControlNo , 1, 1, StopEventCode);
 	Sleep(2);
-	int xstopeven = n_get_value(m_ScannerControlCfg->m_ControlNo->GetValue(), 1);
+	int xstopeven = n_get_value(m_ScannerControlCfg->m_ControlNo , 1);
 
-	n_control_command(m_ScannerControlCfg->m_ControlNo->GetValue(), 1, 2, StopEventCode);
+	n_control_command(m_ScannerControlCfg->m_ControlNo , 1, 2, StopEventCode);
 	Sleep(2);
-	int ystopeven = n_get_value(m_ScannerControlCfg->m_ControlNo->GetValue(), 2);
+	int ystopeven = n_get_value(m_ScannerControlCfg->m_ControlNo , 2);
 
-	int seqNo = m_ScannerControlCfg->m_SeqNo->GetValue();
+	int seqNo = m_ScannerControlCfg->m_SeqNo ;
 	bool isAlarm = false;
 	stringstream ss;
 	char buffer[256];
@@ -716,7 +716,7 @@ void RTC5Scanner::UpdateScannerInfo()
 {
 	if (!m_MachineCfg->m_IsIntelli->GetValue())return;
 
-	int controlNo = m_ScannerControlCfg->m_ControlNo->GetValue();
+	int controlNo = m_ScannerControlCfg->m_ControlNo ;
 	n_control_command(controlNo, 1, 1, ActualPositionAddr);
 	Sleep(2);
 	long xap = n_get_value(controlNo, 1);
@@ -989,7 +989,7 @@ void RTC5Scanner::HeatingScannerRun()
 		sqlength, -sqlength,
 		-sqlength, -sqlength
 	};
-	int controlNo = m_ScannerControlCfg->m_ControlNo->GetValue();
+	int controlNo = m_ScannerControlCfg->m_ControlNo ;
 	double markspeed = m_kfactor* m_ScannerControlCfg->m_ScanCfgWrapper.m_ScanTestCfg.m_AutoHeatingScannerSpeed / 1000.0;
 	int sqsize = (sizeof(square) / sizeof(polygon));
 	n_set_start_list(controlNo, 1);
@@ -1027,5 +1027,5 @@ void RTC5Scanner::HeatingScannerRun()
 
 void RTC5Scanner::ResetDefocus()
 {
-	n_set_defocus(m_ScannerControlCfg->m_ControlNo->GetValue(), 0);
+	n_set_defocus(m_ScannerControlCfg->m_ControlNo , 0);
 }
diff --git a/PrintS/ScannerCtrl/Scanner.cpp b/PrintS/ScannerCtrl/Scanner.cpp
index 36aefe7..3013862 100644
--- a/PrintS/ScannerCtrl/Scanner.cpp
+++ b/PrintS/ScannerCtrl/Scanner.cpp
@@ -166,7 +166,7 @@ bool Scanner::BeginWork()
 DWORD WINAPI Scanner::ScanProc(Scanner* _this)
 {
 	if (_this) {
-		int seqNo = _this->m_ScannerControlCfg->m_SeqNo->GetValue();
+		int seqNo = _this->m_ScannerControlCfg->m_SeqNo ;
 		if (_this->m_MachineCfg->IsDataSeqStragegy())
 		{
 			EnterCriticalSection(&m_SeqCS);
@@ -243,7 +243,7 @@ void Scanner::Clean()
 
 	EnterCriticalSection(&m_SeqCS);
 	if (m_ScannerControlCfg){
-		int seqNo = m_ScannerControlCfg->m_SeqNo->GetValue();
+		int seqNo = m_ScannerControlCfg->m_SeqNo ;
 		m_SeqDataUnFinishBit[seqNo] = false;
 		m_SupportSeqDataUnFinishBit[seqNo] = false;
 	}
@@ -320,7 +320,7 @@ void Scanner::Scan(void)
 		SetSkyWritingEnable(isSkyWritingEnable, true);
 		SetScanSpeed(laserSpeed);
 
-		int seqNo = m_ScannerControlCfg->m_SeqNo->GetValue();
+		int seqNo = m_ScannerControlCfg->m_SeqNo ;
 		g_SystemInfo->m_StateBean.laserParams[seqNo - 1]->laserSpeed = laserSpeed;
 		SetPower(laserPower);
 		g_SystemInfo->m_StateBean.laserParams[seqNo - 1]->laserPower = paramSet->laser_set->laser_power;
@@ -480,7 +480,7 @@ void Scanner::ScanSeqV2() {
 	if (BaseCtrl::IsStop())return;
 
 	EnterCriticalSection(&m_SeqCS);
-	m_SupportSeqDataUnFinishBit[m_ScannerControlCfg->m_SeqNo->GetValue()] = false;
+	m_SupportSeqDataUnFinishBit[m_ScannerControlCfg->m_SeqNo ] = false;
 	LeaveCriticalSection(&m_SeqCS);
 
 	while (true && (!BaseCtrl::IsStop())) {
@@ -640,7 +640,7 @@ void Scanner::ScanSeqV2() {
 			}
 			else {
 				EnterCriticalSection(&m_SeqCS);
-				m_SeqDataUnFinishBit[m_ScannerControlCfg->m_SeqNo->GetValue()] = false;
+				m_SeqDataUnFinishBit[m_ScannerControlCfg->m_SeqNo ] = false;
 				int sb = m_SeqDataUnFinishBit.to_ulong();
 				if (sb == 0) {
 					Printdbi = m_ZeroSeq.front();
@@ -680,13 +680,13 @@ void Scanner::ScanSeqV2() {
 			SetSkyWritingEnable(isSkyWritingEnable, true);
 			SetScanSpeed(laserSpeed);
 
-			g_SystemInfo->m_StateBean.laserParams[m_ScannerControlCfg->m_SeqNo->GetValue() - 1]->laserSpeed = laserSpeed;
+			g_SystemInfo->m_StateBean.laserParams[m_ScannerControlCfg->m_SeqNo  - 1]->laserSpeed = laserSpeed;
 			SetPower(laserPower);
-			g_SystemInfo->m_StateBean.laserParams[m_ScannerControlCfg->m_SeqNo->GetValue() - 1]->laserPower = paramSet->laser_set->laser_power;
+			g_SystemInfo->m_StateBean.laserParams[m_ScannerControlCfg->m_SeqNo  - 1]->laserPower = paramSet->laser_set->laser_power;
 
 			if (m_CorrectParamCfg->m_IsDynamicFocus) {
 				SetDefocus(ds);
-				g_SystemInfo->m_StateBean.laserParams[m_ScannerControlCfg->m_SeqNo->GetValue() - 1]->laserDefocus = ds;
+				g_SystemInfo->m_StateBean.laserParams[m_ScannerControlCfg->m_SeqNo  - 1]->laserDefocus = ds;
 			}
 			EndList();
 			ListExecute(1, nodebug);
@@ -853,7 +853,7 @@ void Scanner::ScanMass() {
 	}
 	if (BaseCtrl::IsStop())return;
 
-	int seqNo = m_ScannerControlCfg->m_SeqNo->GetValue();
+	int seqNo = m_ScannerControlCfg->m_SeqNo ;
 	EnterCriticalSection(&m_SeqCS);
 	m_SupportSeqDataUnFinishBit[seqNo] = false;
 	LeaveCriticalSection(&m_SeqCS);
@@ -1005,7 +1005,7 @@ void Scanner::ScanDataBlock(DataBlockInfo* Printdbi)
 	SetSkyWritingEnable(isSkyWritingEnable, true);
 	SetScanSpeed(laserSpeed);
 
-	int seqNo = m_ScannerControlCfg->m_SeqNo->GetValue();
+	int seqNo = m_ScannerControlCfg->m_SeqNo ;
 	g_SystemInfo->m_StateBean.laserParams[seqNo - 1]->laserSpeed = laserSpeed;
 	SetPower(laserPower);
 	g_SystemInfo->m_StateBean.laserParams[seqNo - 1]->laserPower = paramSet->laser_set->laser_power;
diff --git a/PrintS/ScannerCtrl/ScannerCtrl.cpp b/PrintS/ScannerCtrl/ScannerCtrl.cpp
index f24be56..ef6190b 100644
--- a/PrintS/ScannerCtrl/ScannerCtrl.cpp
+++ b/PrintS/ScannerCtrl/ScannerCtrl.cpp
@@ -88,7 +88,7 @@ bool ScannerCtrl::Init() {
 			for (map<int, ScannerControlCfg*>::iterator scc = scannerControlCfgsMap->begin(); scc != scannerControlCfgsMap->end(); scc++)
 			{
 				ScannerControlCfg* cfg = scc->second;
-				if (cfg->m_SerialNo->GetValue() == s->second)
+				if (cfg->m_SerialNo  == s->second)
 				{
 					find = true;
 					break;
@@ -97,19 +97,19 @@ bool ScannerCtrl::Init() {
 			if (!find && flag < difSize)
 			{
 				ScannerControlCfg* cfg = new ScannerControlCfg();
-				cfg->m_SeqNo->SetValue(scannerControlCfgsMap->size() + 1);
-				cfg->m_CardName->SetValue("Laser" + to_string(cfg->m_SeqNo->GetValue()));
-				cfg->m_ControlNo->SetValue(s->first);
-				cfg->m_ControlType->SetValue(m_MachineCfg->m_ScanControl->GetValue());
-				cfg->m_SerialNo->SetValue(s->second);
-				cfg->m_HadMatch->SetValue(false);
-				cfg->m_IsEnable->SetValue(true);
+				cfg->m_SeqNo=scannerControlCfgsMap->size() + 1;
+				cfg->m_CardName="Laser" + to_string(cfg->m_SeqNo);
+				cfg->m_ControlNo = s->first;
+				cfg->m_ControlType = m_MachineCfg->m_ScanControl->GetValue();
+				cfg->m_SerialNo = s->second;
+				cfg->m_HadMatch = false;
+				cfg->m_IsEnable = true;
 				cfg->Init();
 				//m_Machine->InitScanParamBeforeFind(&cfg->m_ScanCfgWrapper);
 				ConfigManager::GetInstance()->GetScannerControlCfgDao()->Add(cfg);
 				ConfigManager::GetInstance()->GetScannerControlCfgDao()->Maintain(cfg);
 				ConfigManager::GetInstance()->GetScannerControlCfgs()->push_back(cfg);
-				(*scannerControlCfgsMap)[cfg->m_SeqNo->GetValue()] = cfg;
+				(*scannerControlCfgsMap)[cfg->m_SeqNo ] = cfg;
 				flag++;
 			}
 		}
@@ -125,7 +125,7 @@ bool ScannerCtrl::Init() {
 	int index = 0;
 	for (map<int, ScannerControlCfg*>::iterator sit = scannerControlCfgsMap->begin(); sit != scannerControlCfgsMap->end(); sit++) {
 		ScannerControlCfg* cfg = sit->second;
-		int seqNo = cfg->m_SeqNo->GetValue();
+		int seqNo = cfg->m_SeqNo ;
 		if (m_IOCfgWrapper->m_LaserIOMap.find(seqNo) != m_IOCfgWrapper->m_LaserIOMap.end()) {
 			cfg->m_LaserRed = m_IOCfgWrapper->m_LaserIOMap[seqNo]->m_LaserRed;
 			cfg->m_LaserStart = m_IOCfgWrapper->m_LaserIOMap[seqNo]->m_LaserStart;
@@ -778,7 +778,7 @@ void ScannerCtrl::DispatchDataBlock()
 	for (size_t scanIndex = 0; scanIndex < m_scan.size(); ++scanIndex) {
 		Scanner* scanner = m_scan[scanIndex];
 		scanner->m_JobStartTime = job->m_FirstStartTime;
-		scanMap[scanner->GetConfig()->m_SeqNo->GetValue()] = scanner;
+		scanMap[scanner->GetConfig()->m_SeqNo ] = scanner;
 	}
 
 	m_DownSkinStopFlag = 1;
@@ -1258,7 +1258,7 @@ void ScannerCtrl::DispatchDataBlock()
 				sstatus->m_ScanServoTempX = sxy.m_X.m_ServoBoardTemp;
 				sstatus->m_ScanTempY = sxy.m_Y.m_GalvanometerScannerTemp;
 				sstatus->m_ScanServoTempY = sxy.m_Y.m_ServoBoardTemp;
-				sstatus->m_ScanId = m_scan[scanIndex]->GetConfig()->m_SeqNo->GetValue();
+				sstatus->m_ScanId = m_scan[scanIndex]->GetConfig()->m_SeqNo;
 				sstatus->m_JobId = jobBean->m_Id;
 				sstatus->m_LayerIndex = layerindex;
 				sstatus->m_ActualPositionX = sxy.m_X.m_ActualPosition;
@@ -1275,7 +1275,7 @@ void ScannerCtrl::DispatchDataBlock()
 
 				if (m_scan[scanIndex]->GetConfig()->m_ScanCfgWrapper.m_CorrectParamCfg.m_IsDynamicFocus) {
 					FocusStatus* fs = new FocusStatus();
-					fs->m_ScanId = m_scan[scanIndex]->GetConfig()->m_SeqNo->GetValue();
+					fs->m_ScanId = m_scan[scanIndex]->GetConfig()->m_SeqNo ;
 					fs->m_JobId = jobBean->m_Id;
 					fs->m_LayerIndex = layerindex;
 					time(&fs->m_InsertTime);
@@ -1399,7 +1399,7 @@ void ScannerCtrl::DispatchTestDataBlock()
 
 	for (size_t scanIndex = 0; scanIndex < m_scan.size(); ++scanIndex) {
 		Scanner* scanner = m_scan[scanIndex];
-		scanMap[scanner->GetConfig()->m_SeqNo->GetValue()] = scanner;
+		scanMap[scanner->GetConfig()->m_SeqNo ] = scanner;
 		m_scan[scanIndex]->Clean();
 	}
 	for (size_t i = 0; i < m_scan.size(); i++)
@@ -1574,7 +1574,7 @@ void ScannerCtrl::DispatchModelDataBlock(int partId, string scanType, float powe
 	map<int, Scanner*> scanMap;
 	for (size_t scanIndex = 0; scanIndex < m_scan.size(); ++scanIndex) {
 		Scanner* scanner = m_scan[scanIndex];
-		scanMap[scanner->GetConfig()->m_SeqNo->GetValue()] = scanner;
+		scanMap[scanner->GetConfig()->m_SeqNo ] = scanner;
 		m_scan[scanIndex]->Clean();
 	}
 
@@ -1812,7 +1812,7 @@ void ScannerCtrl::RemoveScanner(int seq)
 {
 	for (vector<Scanner*>::iterator it = m_scan.begin(); it != m_scan.end();) {
 		Scanner* s = (*it);
-		if (s->GetConfig()->m_SeqNo->GetValue() == seq)
+		if (s->GetConfig()->m_SeqNo  == seq)
 		{
 			delete s;
 			it = m_scan.erase(it);
@@ -2017,7 +2017,7 @@ void ScannerCtrl::SendToClients() {
 
 	auto iter = Scanner::m_CurrentSerio.begin();
 	while (iter != Scanner::m_CurrentSerio.end()) {
-		lst.emplace_back(Item{ to_string(iter->first), to_string(iter->second), iUINT });
+		lst.emplace_back(Item(to_string(iter->first), to_string(iter->second), iUINT ));
 		++iter;
 	}
 	
diff --git a/PrintS/additional/Calibration.cpp b/PrintS/additional/Calibration.cpp
index 9974b5d..04e70ee 100644
--- a/PrintS/additional/Calibration.cpp
+++ b/PrintS/additional/Calibration.cpp
@@ -959,7 +959,7 @@ void Calibration::GraftRun()
 				float mminy = rt.y;
 				float mmaxy = rt.y + rt.height;
 				if (mminx >lminx && lmaxx>mmaxx && mminy >lminy && lmaxy > mmaxy) {
-					matchLaser = (*cfgs)[lindex]->m_SeqNo->GetValue();
+					matchLaser = (*cfgs)[lindex]->m_SeqNo ;
 					break;
 				}
 			}
@@ -976,7 +976,7 @@ void Calibration::GraftRun()
 				float mminy = rt2.y;
 				float mmaxy = rt2.y + rt2.height;
 				if (mminx > lminx && lmaxx > mmaxx && mminy > lminy && lmaxy > mmaxy) {
-					dataLaser = (*cfgs)[lindex]->m_SeqNo->GetValue();
+					dataLaser = (*cfgs)[lindex]->m_SeqNo ;
 					break;
 				}
 			}
diff --git a/PrintS/job/H3DFileProcessor.cpp b/PrintS/job/H3DFileProcessor.cpp
index 575674f..98c28de 100644
--- a/PrintS/job/H3DFileProcessor.cpp
+++ b/PrintS/job/H3DFileProcessor.cpp
@@ -121,9 +121,9 @@ int H3DFileProcessor::Process(string jobfile)
 
 				if ((sf->dimension->xmin >= cfg_xmin) && (sf->dimension->xmax <= cfg_xmax) && (sf->dimension->ymin >= cfg_ymin) && (sf->dimension->ymax <= cfg_ymax)) {
 					canSelectIndexs.push(laserIndex);
-					if (!hasSelected[cfg->m_SeqNo->GetValue()]) {
+					if (!hasSelected[cfg->m_SeqNo ]) {
 						metadata->m_FieldRefScanLaser[sf->id] = cfg;
-						hasSelected[cfg->m_SeqNo->GetValue()] = 1;
+						hasSelected[cfg->m_SeqNo ] = 1;
 						hasfind = true;
 						break;
 					}
@@ -278,7 +278,7 @@ int H3DFileProcessor::Process(string jobfile)
 				}
 
 				if (laserCfg) {
-					db->cno = laserCfg->m_SeqNo->GetValue();
+					db->cno = laserCfg->m_SeqNo ;
 				}
 			}
 			else {
diff --git a/PrintS/job/JobMetaData.cpp b/PrintS/job/JobMetaData.cpp
index 62da079..67bc753 100644
--- a/PrintS/job/JobMetaData.cpp
+++ b/PrintS/job/JobMetaData.cpp
@@ -796,7 +796,7 @@ void XMLCALL JobMetaData::EndElement(void* userData, const XML_Char* name)
 			}
 
 			if (laserCfg) {
-				job->parseAssist.lastDataBlock->cno = laserCfg->m_SeqNo->GetValue();
+				job->parseAssist.lastDataBlock->cno = laserCfg->m_SeqNo ;
 			}
 		}
 	}
@@ -1033,9 +1033,9 @@ void XMLCALL JobMetaData::EndElement(void* userData, const XML_Char* name)
 
 					if ((sf->dimension->xmin >= cfg_xmin) && (sf->dimension->xmax <= cfg_xmax) && (sf->dimension->ymin >= cfg_ymin) && (sf->dimension->ymax <= cfg_ymax)) {
 						canSelectIndexs.push(laserIndex);
-						if (!hasSelected[cfg->m_SeqNo->GetValue()]) {
+						if (!hasSelected[cfg->m_SeqNo ]) {
 							job->m_FieldRefScanLaser[sf->id] = cfg;
-							hasSelected[cfg->m_SeqNo->GetValue()] = 1;
+							hasSelected[cfg->m_SeqNo ] = 1;
 							hasfind = true;
 							break;
 						}
diff --git a/PrintS/job/MetaData.cpp b/PrintS/job/MetaData.cpp
index d829874..b71e19c 100644
--- a/PrintS/job/MetaData.cpp
+++ b/PrintS/job/MetaData.cpp
@@ -458,7 +458,7 @@ void MetaData::ReCalcEvaTime()
 				sum = markMil + jumpMil + hatching + jumpdelay + markdelay + 20.0 + flag;
 				datablock->scanTime = sum;
 				//	milsec += sum;
-				layer->estimateTimeMap[laserCfg->m_SeqNo->GetValue()] += sum;
+				layer->estimateTimeMap[laserCfg->m_SeqNo ] += sum;
 			}
 			double max = 0.0;
 			for (map<int, double>::iterator it = layer->estimateTimeMap.begin(); it != layer->estimateTimeMap.end(); it++) {
diff --git a/PrintS/output/Release/log/2024.hbd b/PrintS/output/Release/log/2024.hbd
index 65ce366..2ca9619 100644
Binary files a/PrintS/output/Release/log/2024.hbd and b/PrintS/output/Release/log/2024.hbd differ
diff --git a/PrintS/protobuf/stream.pb.cc b/PrintS/protobuf/stream.pb.cc
index 4f1ed96..e7673c2 100644
--- a/PrintS/protobuf/stream.pb.cc
+++ b/PrintS/protobuf/stream.pb.cc
@@ -36,13 +36,27 @@ PROTOBUF_CONSTEXPR ParamInfo::ParamInfo(::_pbi::ConstantInitialized)
           &::_pbi::fixed_address_empty_string,
           ::_pbi::ConstantInitialized{},
       },
+      /*decltype(_impl_.cardname_)*/ {
+          &::_pbi::fixed_address_empty_string,
+          ::_pbi::ConstantInitialized{},
+      },
+      /*decltype(_impl_.cardip_)*/ {
+          &::_pbi::fixed_address_empty_string,
+          ::_pbi::ConstantInitialized{},
+      },
       /*decltype(_impl_.valuetype_)*/ 0,
+      /*decltype(_impl_.startlayer_)*/ 0,
       /*decltype(_impl_.isenable_)*/ false,
       /*decltype(_impl_.isalarm_)*/ false,
       /*decltype(_impl_.isshow_)*/ false,
-      /*decltype(_impl_.startlayer_)*/ 0,
+      /*decltype(_impl_.hadassign_)*/ false,
       /*decltype(_impl_.endlayer_)*/ 0,
       /*decltype(_impl_.powder_)*/ 0,
+      /*decltype(_impl_.seqno_)*/ 0,
+      /*decltype(_impl_.controlno_)*/ 0,
+      /*decltype(_impl_.serialno_)*/ 0,
+      /*decltype(_impl_.controltype_)*/ 0,
+      /*decltype(_impl_.hadmatch_)*/ false,
       /*decltype(_impl_._cached_size_)*/ {},
     } {}
 struct ParamInfoDefaultTypeInternal {
@@ -264,8 +278,280 @@ struct ComResponceDefaultTypeInternal {
 
 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
     PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ComResponceDefaultTypeInternal _ComResponce_default_instance_;
+        template <typename>
+PROTOBUF_CONSTEXPR ScannerCrtlCfgResp::ScannerCrtlCfgResp(::_pbi::ConstantInitialized)
+    : _impl_{
+      /*decltype(_impl_.scannercfg_)*/ {},
+      /*decltype(_impl_._cached_size_)*/ {},
+    } {}
+struct ScannerCrtlCfgRespDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ScannerCrtlCfgRespDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ScannerCrtlCfgRespDefaultTypeInternal() {}
+  union {
+    ScannerCrtlCfgResp _instance;
+  };
+};
+
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
+    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ScannerCrtlCfgRespDefaultTypeInternal _ScannerCrtlCfgResp_default_instance_;
+        template <typename>
+PROTOBUF_CONSTEXPR ScannerCrtlCfgData::ScannerCrtlCfgData(::_pbi::ConstantInitialized)
+    : _impl_{
+      /*decltype(_impl_._has_bits_)*/ {},
+      /*decltype(_impl_._cached_size_)*/ {},
+      /*decltype(_impl_.fixpointdata_)*/ {},
+      /*decltype(_impl_.powercompensate_)*/ {},
+      /*decltype(_impl_.tpowercompensate_)*/ {},
+      /*decltype(_impl_.cardname_)*/ {
+          &::_pbi::fixed_address_empty_string,
+          ::_pbi::ConstantInitialized{},
+      },
+      /*decltype(_impl_.cardip_)*/ {
+          &::_pbi::fixed_address_empty_string,
+          ::_pbi::ConstantInitialized{},
+      },
+      /*decltype(_impl_.scanparamcfg_)*/ nullptr,
+      /*decltype(_impl_.hatchingparams_)*/ nullptr,
+      /*decltype(_impl_.borderparams_)*/ nullptr,
+      /*decltype(_impl_.supportparams_)*/ nullptr,
+      /*decltype(_impl_.correctparamcfg_)*/ nullptr,
+      /*decltype(_impl_.scantestcfg_)*/ nullptr,
+      /*decltype(_impl_.skywritingcfg_)*/ nullptr,
+      /*decltype(_impl_.seqno_)*/ 0,
+      /*decltype(_impl_.controlno_)*/ 0,
+      /*decltype(_impl_.serialno_)*/ 0,
+      /*decltype(_impl_.controltype_)*/ 0,
+      /*decltype(_impl_.isenable_)*/ false,
+      /*decltype(_impl_.hadassign_)*/ false,
+      /*decltype(_impl_.hadmatch_)*/ false,
+    } {}
+struct ScannerCrtlCfgDataDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ScannerCrtlCfgDataDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ScannerCrtlCfgDataDefaultTypeInternal() {}
+  union {
+    ScannerCrtlCfgData _instance;
+  };
+};
+
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
+    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ScannerCrtlCfgDataDefaultTypeInternal _ScannerCrtlCfgData_default_instance_;
+        template <typename>
+PROTOBUF_CONSTEXPR FixPointData::FixPointData(::_pbi::ConstantInitialized)
+    : _impl_{
+      /*decltype(_impl_.id_)*/ 0,
+      /*decltype(_impl_.cno_)*/ 0,
+      /*decltype(_impl_.pointx_)*/ 0,
+      /*decltype(_impl_.pointy_)*/ 0,
+      /*decltype(_impl_.duration_)*/ 0u,
+      /*decltype(_impl_._cached_size_)*/ {},
+    } {}
+struct FixPointDataDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR FixPointDataDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
+  ~FixPointDataDefaultTypeInternal() {}
+  union {
+    FixPointData _instance;
+  };
+};
+
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
+    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FixPointDataDefaultTypeInternal _FixPointData_default_instance_;
+        template <typename>
+PROTOBUF_CONSTEXPR ScanParamCfg::ScanParamCfg(::_pbi::ConstantInitialized)
+    : _impl_{
+      /*decltype(_impl_.edgelevel_)*/ 0,
+      /*decltype(_impl_.edgelevelmin_)*/ 0,
+      /*decltype(_impl_.edgelevelmax_)*/ 0,
+      /*decltype(_impl_.jumpdelay_)*/ 0u,
+      /*decltype(_impl_.jumpdelaymin_)*/ 0u,
+      /*decltype(_impl_.jumpdelaymax_)*/ 0u,
+      /*decltype(_impl_.scandelay_)*/ 0u,
+      /*decltype(_impl_.scandelaymin_)*/ 0u,
+      /*decltype(_impl_.scandelaymax_)*/ 0u,
+      /*decltype(_impl_.polygondelay_)*/ 0u,
+      /*decltype(_impl_.polygondelaymin_)*/ 0u,
+      /*decltype(_impl_.polygondelaymax_)*/ 0u,
+      /*decltype(_impl_.laseroffdelay_)*/ ::int64_t{0},
+      /*decltype(_impl_.laseroffdelaymin_)*/ ::int64_t{0},
+      /*decltype(_impl_.laseroffdelaymax_)*/ ::int64_t{0},
+      /*decltype(_impl_.laserondelay_)*/ ::int64_t{0},
+      /*decltype(_impl_.laserondelaymin_)*/ ::int64_t{0},
+      /*decltype(_impl_.laserondelaymax_)*/ ::int64_t{0},
+      /*decltype(_impl_.minjumpdelay_)*/ 0u,
+      /*decltype(_impl_.minjumpdelaymin_)*/ 0u,
+      /*decltype(_impl_.minjumpdelaymax_)*/ 0u,
+      /*decltype(_impl_.jumplengthlimit_)*/ 0u,
+      /*decltype(_impl_.jumplengthlimitmin_)*/ 0u,
+      /*decltype(_impl_.jumplengthlimitmax_)*/ 0u,
+      /*decltype(_impl_.jumpspeed_)*/ 0,
+      /*decltype(_impl_.jumpspeedmin_)*/ 0,
+      /*decltype(_impl_.jumpspeedmax_)*/ 0,
+      /*decltype(_impl_.markspeed_)*/ 0,
+      /*decltype(_impl_.markspeedmin_)*/ 0,
+      /*decltype(_impl_.markspeedmax_)*/ 0,
+      /*decltype(_impl_._cached_size_)*/ {},
+    } {}
+struct ScanParamCfgDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ScanParamCfgDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ScanParamCfgDefaultTypeInternal() {}
+  union {
+    ScanParamCfg _instance;
+  };
+};
+
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
+    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ScanParamCfgDefaultTypeInternal _ScanParamCfg_default_instance_;
+        template <typename>
+PROTOBUF_CONSTEXPR CorrectParamCfg::CorrectParamCfg(::_pbi::ConstantInitialized)
+    : _impl_{
+      /*decltype(_impl_.xmeasuremin_)*/ 0,
+      /*decltype(_impl_.xmeasuremax_)*/ 0,
+      /*decltype(_impl_.ymeasuremin_)*/ 0,
+      /*decltype(_impl_.ymeasuremax_)*/ 0,
+      /*decltype(_impl_.xposfix_)*/ 0,
+      /*decltype(_impl_.yposfix_)*/ 0,
+      /*decltype(_impl_.scanangle_)*/ 0,
+      /*decltype(_impl_.scananglemin_)*/ 0,
+      /*decltype(_impl_.scananglemax_)*/ 0,
+      /*decltype(_impl_.fixangle_)*/ 0,
+      /*decltype(_impl_.fixanglemin_)*/ 0,
+      /*decltype(_impl_.fixanglemax_)*/ 0,
+      /*decltype(_impl_.xcorrect_)*/ 0,
+      /*decltype(_impl_.ycorrect_)*/ 0,
+      /*decltype(_impl_.xcorrectmin_)*/ 0,
+      /*decltype(_impl_.xcorrectmax_)*/ 0,
+      /*decltype(_impl_.ycorrectmin_)*/ 0,
+      /*decltype(_impl_.ycorrectmax_)*/ 0,
+      /*decltype(_impl_.realxoffset_)*/ 0,
+      /*decltype(_impl_.realyoffset_)*/ 0,
+      /*decltype(_impl_.factork_)*/ 0,
+      /*decltype(_impl_.defocusratio_)*/ 0,
+      /*decltype(_impl_.defocusratiomin_)*/ 0,
+      /*decltype(_impl_.defocusratiomax_)*/ 0,
+      /*decltype(_impl_.iscorrectfile3d_)*/ false,
+      /*decltype(_impl_.isdynamicfocus_)*/ false,
+      /*decltype(_impl_._cached_size_)*/ {},
+    } {}
+struct CorrectParamCfgDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR CorrectParamCfgDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
+  ~CorrectParamCfgDefaultTypeInternal() {}
+  union {
+    CorrectParamCfg _instance;
+  };
+};
+
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
+    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CorrectParamCfgDefaultTypeInternal _CorrectParamCfg_default_instance_;
+        template <typename>
+PROTOBUF_CONSTEXPR ScanTestCfg::ScanTestCfg(::_pbi::ConstantInitialized)
+    : _impl_{
+      /*decltype(_impl_.debugshape_)*/ 0,
+      /*decltype(_impl_.shapesize_)*/ 0,
+      /*decltype(_impl_.shapesizemin_)*/ 0,
+      /*decltype(_impl_.shape_size_max_)*/ 0,
+      /*decltype(_impl_.laser_power_)*/ 0,
+      /*decltype(_impl_.laser_power_min_)*/ 0,
+      /*decltype(_impl_.defocus_)*/ 0,
+      /*decltype(_impl_.defocus_min_)*/ 0,
+      /*decltype(_impl_.defocus_max_)*/ 0,
+      /*decltype(_impl_.laser_power_max_)*/ 0,
+      /*decltype(_impl_.is_cycle_)*/ false,
+      /*decltype(_impl_.isautoheatingscanner_)*/ false,
+      /*decltype(_impl_.cross_x_)*/ 0,
+      /*decltype(_impl_.cross_y_)*/ 0,
+      /*decltype(_impl_.z_distance_)*/ 0,
+      /*decltype(_impl_.autoheatingscannerminutes_)*/ 0u,
+      /*decltype(_impl_.autoheatingscannersize_)*/ 0u,
+      /*decltype(_impl_.autoheatingscannerspeed_)*/ 0,
+      /*decltype(_impl_.mark_test_start_x_)*/ 0,
+      /*decltype(_impl_.mark_test_start_y_)*/ 0,
+      /*decltype(_impl_.mark_test_end_x_)*/ 0,
+      /*decltype(_impl_.mark_test_end_y_)*/ 0,
+      /*decltype(_impl_._cached_size_)*/ {},
+    } {}
+struct ScanTestCfgDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ScanTestCfgDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ScanTestCfgDefaultTypeInternal() {}
+  union {
+    ScanTestCfg _instance;
+  };
+};
+
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
+    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ScanTestCfgDefaultTypeInternal _ScanTestCfg_default_instance_;
+        template <typename>
+PROTOBUF_CONSTEXPR SkyWritingCfg::SkyWritingCfg(::_pbi::ConstantInitialized)
+    : _impl_{
+      /*decltype(_impl_.timelag_)*/ 0,
+      /*decltype(_impl_.timelagmin_)*/ 0,
+      /*decltype(_impl_.timelagmax_)*/ 0,
+      /*decltype(_impl_.isenable_)*/ false,
+      /*decltype(_impl_.nprev_)*/ 0u,
+      /*decltype(_impl_.laseronshift_)*/ ::int64_t{0},
+      /*decltype(_impl_.laseronshiftmin_)*/ ::int64_t{0},
+      /*decltype(_impl_.laseronshiftmax_)*/ ::int64_t{0},
+      /*decltype(_impl_.nprevmin_)*/ 0u,
+      /*decltype(_impl_.nprevmax_)*/ 0u,
+      /*decltype(_impl_.npost_)*/ 0u,
+      /*decltype(_impl_.npostmin_)*/ 0u,
+      /*decltype(_impl_.npostmax_)*/ 0u,
+      /*decltype(_impl_.mode_)*/ 0,
+      /*decltype(_impl_.limite_)*/ 0,
+      /*decltype(_impl_.limitemin_)*/ 0,
+      /*decltype(_impl_.limitemax_)*/ 0,
+      /*decltype(_impl_._cached_size_)*/ {},
+    } {}
+struct SkyWritingCfgDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR SkyWritingCfgDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
+  ~SkyWritingCfgDefaultTypeInternal() {}
+  union {
+    SkyWritingCfg _instance;
+  };
+};
+
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
+    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SkyWritingCfgDefaultTypeInternal _SkyWritingCfg_default_instance_;
+        template <typename>
+PROTOBUF_CONSTEXPR PowerCompensate::PowerCompensate(::_pbi::ConstantInitialized)
+    : _impl_{
+      /*decltype(_impl_.cno_)*/ 0,
+      /*decltype(_impl_.percent_)*/ 0,
+      /*decltype(_impl_.value_)*/ 0,
+      /*decltype(_impl_.value_min_)*/ 0,
+      /*decltype(_impl_.value_max_)*/ 0,
+      /*decltype(_impl_._cached_size_)*/ {},
+    } {}
+struct PowerCompensateDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR PowerCompensateDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
+  ~PowerCompensateDefaultTypeInternal() {}
+  union {
+    PowerCompensate _instance;
+  };
+};
+
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
+    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PowerCompensateDefaultTypeInternal _PowerCompensate_default_instance_;
+        template <typename>
+PROTOBUF_CONSTEXPR TimePowerCompensate::TimePowerCompensate(::_pbi::ConstantInitialized)
+    : _impl_{
+      /*decltype(_impl_.id_)*/ 0,
+      /*decltype(_impl_.cno_)*/ 0,
+      /*decltype(_impl_.startminute_)*/ 0u,
+      /*decltype(_impl_.endminute_)*/ 0u,
+      /*decltype(_impl_.compensate_)*/ 0,
+      /*decltype(_impl_._cached_size_)*/ {},
+    } {}
+struct TimePowerCompensateDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR TimePowerCompensateDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
+  ~TimePowerCompensateDefaultTypeInternal() {}
+  union {
+    TimePowerCompensate _instance;
+  };
+};
+
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
+    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TimePowerCompensateDefaultTypeInternal _TimePowerCompensate_default_instance_;
 }  // namespace stream
-static ::_pb::Metadata file_level_metadata_stream_2eproto[12];
+static ::_pb::Metadata file_level_metadata_stream_2eproto[21];
 static const ::_pb::EnumDescriptor* file_level_enum_descriptors_stream_2eproto[2];
 static constexpr const ::_pb::ServiceDescriptor**
     file_level_service_descriptors_stream_2eproto = nullptr;
@@ -289,6 +575,14 @@ const ::uint32_t TableStruct_stream_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE
     PROTOBUF_FIELD_OFFSET(::stream::ParamInfo, _impl_.startlayer_),
     PROTOBUF_FIELD_OFFSET(::stream::ParamInfo, _impl_.endlayer_),
     PROTOBUF_FIELD_OFFSET(::stream::ParamInfo, _impl_.powder_),
+    PROTOBUF_FIELD_OFFSET(::stream::ParamInfo, _impl_.seqno_),
+    PROTOBUF_FIELD_OFFSET(::stream::ParamInfo, _impl_.controlno_),
+    PROTOBUF_FIELD_OFFSET(::stream::ParamInfo, _impl_.serialno_),
+    PROTOBUF_FIELD_OFFSET(::stream::ParamInfo, _impl_.controltype_),
+    PROTOBUF_FIELD_OFFSET(::stream::ParamInfo, _impl_.cardname_),
+    PROTOBUF_FIELD_OFFSET(::stream::ParamInfo, _impl_.cardip_),
+    PROTOBUF_FIELD_OFFSET(::stream::ParamInfo, _impl_.hadassign_),
+    PROTOBUF_FIELD_OFFSET(::stream::ParamInfo, _impl_.hadmatch_),
     ~0u,  // no _has_bits_
     PROTOBUF_FIELD_OFFSET(::stream::RequestInfo, _internal_metadata_),
     ~0u,  // no _extensions_
@@ -412,22 +706,252 @@ const ::uint32_t TableStruct_stream_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE
     ~0u,  // no _split_
     ~0u,  // no sizeof(Split)
     PROTOBUF_FIELD_OFFSET(::stream::ComResponce, _impl_.data_),
+    ~0u,  // no _has_bits_
+    PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgResp, _internal_metadata_),
+    ~0u,  // no _extensions_
+    ~0u,  // no _oneof_case_
+    ~0u,  // no _weak_field_map_
+    ~0u,  // no _inlined_string_donated_
+    ~0u,  // no _split_
+    ~0u,  // no sizeof(Split)
+    PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgResp, _impl_.scannercfg_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_._has_bits_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _internal_metadata_),
+    ~0u,  // no _extensions_
+    ~0u,  // no _oneof_case_
+    ~0u,  // no _weak_field_map_
+    ~0u,  // no _inlined_string_donated_
+    ~0u,  // no _split_
+    ~0u,  // no sizeof(Split)
+    PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.seqno_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.fixpointdata_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.scanparamcfg_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.hatchingparams_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.borderparams_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.supportparams_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.correctparamcfg_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.scantestcfg_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.skywritingcfg_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.powercompensate_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.tpowercompensate_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.controlno_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.serialno_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.controltype_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.cardname_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.cardip_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.isenable_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.hadassign_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.hadmatch_),
+    ~0u,
+    ~0u,
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    ~0u,
+    ~0u,
+    ~0u,
+    ~0u,
+    ~0u,
+    ~0u,
+    ~0u,
+    ~0u,
+    ~0u,
+    ~0u,
+    ~0u,  // no _has_bits_
+    PROTOBUF_FIELD_OFFSET(::stream::FixPointData, _internal_metadata_),
+    ~0u,  // no _extensions_
+    ~0u,  // no _oneof_case_
+    ~0u,  // no _weak_field_map_
+    ~0u,  // no _inlined_string_donated_
+    ~0u,  // no _split_
+    ~0u,  // no sizeof(Split)
+    PROTOBUF_FIELD_OFFSET(::stream::FixPointData, _impl_.id_),
+    PROTOBUF_FIELD_OFFSET(::stream::FixPointData, _impl_.cno_),
+    PROTOBUF_FIELD_OFFSET(::stream::FixPointData, _impl_.pointx_),
+    PROTOBUF_FIELD_OFFSET(::stream::FixPointData, _impl_.pointy_),
+    PROTOBUF_FIELD_OFFSET(::stream::FixPointData, _impl_.duration_),
+    ~0u,  // no _has_bits_
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _internal_metadata_),
+    ~0u,  // no _extensions_
+    ~0u,  // no _oneof_case_
+    ~0u,  // no _weak_field_map_
+    ~0u,  // no _inlined_string_donated_
+    ~0u,  // no _split_
+    ~0u,  // no sizeof(Split)
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.edgelevel_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.edgelevelmin_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.edgelevelmax_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.jumpdelay_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.jumpdelaymin_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.jumpdelaymax_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.scandelay_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.scandelaymin_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.scandelaymax_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.polygondelay_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.polygondelaymin_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.polygondelaymax_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.laseroffdelay_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.laseroffdelaymin_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.laseroffdelaymax_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.laserondelay_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.laserondelaymin_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.laserondelaymax_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.minjumpdelay_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.minjumpdelaymin_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.minjumpdelaymax_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.jumplengthlimit_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.jumplengthlimitmin_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.jumplengthlimitmax_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.jumpspeed_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.jumpspeedmin_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.jumpspeedmax_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.markspeed_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.markspeedmin_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.markspeedmax_),
+    ~0u,  // no _has_bits_
+    PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _internal_metadata_),
+    ~0u,  // no _extensions_
+    ~0u,  // no _oneof_case_
+    ~0u,  // no _weak_field_map_
+    ~0u,  // no _inlined_string_donated_
+    ~0u,  // no _split_
+    ~0u,  // no sizeof(Split)
+    PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.xmeasuremin_),
+    PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.xmeasuremax_),
+    PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.ymeasuremin_),
+    PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.ymeasuremax_),
+    PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.xposfix_),
+    PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.yposfix_),
+    PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.scanangle_),
+    PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.scananglemin_),
+    PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.scananglemax_),
+    PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.fixangle_),
+    PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.fixanglemin_),
+    PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.fixanglemax_),
+    PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.xcorrect_),
+    PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.ycorrect_),
+    PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.xcorrectmin_),
+    PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.xcorrectmax_),
+    PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.ycorrectmin_),
+    PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.ycorrectmax_),
+    PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.realxoffset_),
+    PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.realyoffset_),
+    PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.factork_),
+    PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.iscorrectfile3d_),
+    PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.isdynamicfocus_),
+    PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.defocusratio_),
+    PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.defocusratiomin_),
+    PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.defocusratiomax_),
+    ~0u,  // no _has_bits_
+    PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _internal_metadata_),
+    ~0u,  // no _extensions_
+    ~0u,  // no _oneof_case_
+    ~0u,  // no _weak_field_map_
+    ~0u,  // no _inlined_string_donated_
+    ~0u,  // no _split_
+    ~0u,  // no sizeof(Split)
+    PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.debugshape_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.shapesize_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.shapesizemin_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.shape_size_max_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.laser_power_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.laser_power_min_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.laser_power_max_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.defocus_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.defocus_min_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.defocus_max_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.is_cycle_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.cross_x_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.cross_y_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.z_distance_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.isautoheatingscanner_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.autoheatingscannerminutes_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.autoheatingscannersize_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.autoheatingscannerspeed_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.mark_test_start_x_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.mark_test_start_y_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.mark_test_end_x_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.mark_test_end_y_),
+    ~0u,  // no _has_bits_
+    PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _internal_metadata_),
+    ~0u,  // no _extensions_
+    ~0u,  // no _oneof_case_
+    ~0u,  // no _weak_field_map_
+    ~0u,  // no _inlined_string_donated_
+    ~0u,  // no _split_
+    ~0u,  // no sizeof(Split)
+    PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.isenable_),
+    PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.timelag_),
+    PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.timelagmin_),
+    PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.timelagmax_),
+    PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.laseronshift_),
+    PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.laseronshiftmin_),
+    PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.laseronshiftmax_),
+    PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.nprev_),
+    PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.nprevmin_),
+    PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.nprevmax_),
+    PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.npost_),
+    PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.npostmin_),
+    PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.npostmax_),
+    PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.mode_),
+    PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.limite_),
+    PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.limitemin_),
+    PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.limitemax_),
+    ~0u,  // no _has_bits_
+    PROTOBUF_FIELD_OFFSET(::stream::PowerCompensate, _internal_metadata_),
+    ~0u,  // no _extensions_
+    ~0u,  // no _oneof_case_
+    ~0u,  // no _weak_field_map_
+    ~0u,  // no _inlined_string_donated_
+    ~0u,  // no _split_
+    ~0u,  // no sizeof(Split)
+    PROTOBUF_FIELD_OFFSET(::stream::PowerCompensate, _impl_.cno_),
+    PROTOBUF_FIELD_OFFSET(::stream::PowerCompensate, _impl_.percent_),
+    PROTOBUF_FIELD_OFFSET(::stream::PowerCompensate, _impl_.value_),
+    PROTOBUF_FIELD_OFFSET(::stream::PowerCompensate, _impl_.value_min_),
+    PROTOBUF_FIELD_OFFSET(::stream::PowerCompensate, _impl_.value_max_),
+    ~0u,  // no _has_bits_
+    PROTOBUF_FIELD_OFFSET(::stream::TimePowerCompensate, _internal_metadata_),
+    ~0u,  // no _extensions_
+    ~0u,  // no _oneof_case_
+    ~0u,  // no _weak_field_map_
+    ~0u,  // no _inlined_string_donated_
+    ~0u,  // no _split_
+    ~0u,  // no sizeof(Split)
+    PROTOBUF_FIELD_OFFSET(::stream::TimePowerCompensate, _impl_.id_),
+    PROTOBUF_FIELD_OFFSET(::stream::TimePowerCompensate, _impl_.cno_),
+    PROTOBUF_FIELD_OFFSET(::stream::TimePowerCompensate, _impl_.startminute_),
+    PROTOBUF_FIELD_OFFSET(::stream::TimePowerCompensate, _impl_.endminute_),
+    PROTOBUF_FIELD_OFFSET(::stream::TimePowerCompensate, _impl_.compensate_),
 };
 
 static const ::_pbi::MigrationSchema
     schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
         {0, -1, -1, sizeof(::stream::ParamInfo)},
-        {18, -1, -1, sizeof(::stream::RequestInfo)},
-        {32, -1, -1, sizeof(::stream::ResponseInfo)},
-        {43, 52, -1, sizeof(::stream::ResponseAny)},
-        {53, -1, -1, sizeof(::stream::LayerData)},
-        {66, -1, -1, sizeof(::stream::LayerDataBlock)},
-        {80, -1, -1, sizeof(::stream::VectorDataBlock)},
-        {92, -1, -1, sizeof(::stream::ChainDataBlock)},
-        {102, -1, -1, sizeof(::stream::Point)},
-        {112, -1, -1, sizeof(::stream::RegResponce)},
-        {121, -1, -1, sizeof(::stream::ImgInfoResponce)},
-        {132, -1, -1, sizeof(::stream::ComResponce)},
+        {26, -1, -1, sizeof(::stream::RequestInfo)},
+        {40, -1, -1, sizeof(::stream::ResponseInfo)},
+        {51, 60, -1, sizeof(::stream::ResponseAny)},
+        {61, -1, -1, sizeof(::stream::LayerData)},
+        {74, -1, -1, sizeof(::stream::LayerDataBlock)},
+        {88, -1, -1, sizeof(::stream::VectorDataBlock)},
+        {100, -1, -1, sizeof(::stream::ChainDataBlock)},
+        {110, -1, -1, sizeof(::stream::Point)},
+        {120, -1, -1, sizeof(::stream::RegResponce)},
+        {129, -1, -1, sizeof(::stream::ImgInfoResponce)},
+        {140, -1, -1, sizeof(::stream::ComResponce)},
+        {149, -1, -1, sizeof(::stream::ScannerCrtlCfgResp)},
+        {158, 185, -1, sizeof(::stream::ScannerCrtlCfgData)},
+        {204, -1, -1, sizeof(::stream::FixPointData)},
+        {217, -1, -1, sizeof(::stream::ScanParamCfg)},
+        {255, -1, -1, sizeof(::stream::CorrectParamCfg)},
+        {289, -1, -1, sizeof(::stream::ScanTestCfg)},
+        {319, -1, -1, sizeof(::stream::SkyWritingCfg)},
+        {344, -1, -1, sizeof(::stream::PowerCompensate)},
+        {357, -1, -1, sizeof(::stream::TimePowerCompensate)},
 };
 
 static const ::_pb::Message* const file_default_instances[] = {
@@ -443,51 +967,143 @@ static const ::_pb::Message* const file_default_instances[] = {
     &::stream::_RegResponce_default_instance_._instance,
     &::stream::_ImgInfoResponce_default_instance_._instance,
     &::stream::_ComResponce_default_instance_._instance,
+    &::stream::_ScannerCrtlCfgResp_default_instance_._instance,
+    &::stream::_ScannerCrtlCfgData_default_instance_._instance,
+    &::stream::_FixPointData_default_instance_._instance,
+    &::stream::_ScanParamCfg_default_instance_._instance,
+    &::stream::_CorrectParamCfg_default_instance_._instance,
+    &::stream::_ScanTestCfg_default_instance_._instance,
+    &::stream::_SkyWritingCfg_default_instance_._instance,
+    &::stream::_PowerCompensate_default_instance_._instance,
+    &::stream::_TimePowerCompensate_default_instance_._instance,
 };
 const char descriptor_table_protodef_stream_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
     "\n\014stream.proto\022\006stream\032\031google/protobuf/"
-    "any.proto\"\311\001\n\tParamInfo\022\017\n\007nameKey\030\001 \001(\014"
+    "any.proto\"\331\002\n\tParamInfo\022\017\n\007nameKey\030\001 \001(\014"
     "\022\020\n\010strValue\030\002 \001(\014\022\037\n\tvalueType\030\003 \001(\0162\014."
     "stream.TYPE\022\017\n\007context\030\004 \001(\014\022\020\n\010isEnable"
     "\030\005 \001(\010\022\017\n\007isAlarm\030\006 \001(\010\022\016\n\006isShow\030\007 \001(\010\022"
     "\022\n\nstartLayer\030\010 \001(\005\022\020\n\010endLayer\030\t \001(\005\022\016\n"
-    "\006powder\030\n \001(\002\"\254\001\n\013RequestInfo\022\020\n\010dataTyp"
-    "e\030\001 \001(\r\022\017\n\007nameKey\030\002 \001(\014\022\020\n\010strValue\030\003 \001"
-    "(\014\022\037\n\tvalueType\030\004 \001(\0162\014.stream.TYPE\022&\n\nh"
-    "andleType\030\005 \001(\0162\022.stream.DATAHANDLE\022\037\n\004i"
-    "tem\030\006 \003(\0132\021.stream.ParamInfo\"Q\n\014Response"
-    "Info\022\020\n\010dataType\030\001 \001(\r\022\016\n\006result\030\002 \001(\010\022\037"
-    "\n\004item\030\003 \003(\0132\021.stream.ParamInfo\"1\n\013Respo"
-    "nseAny\022\"\n\004data\030\001 \001(\0132\024.google.protobuf.A"
-    "ny\"\210\001\n\tLayerData\022\023\n\013zCooldinate\030\001 \001(\002\022\016\n"
-    "\006powder\030\002 \001(\002\022\026\n\016layerThickness\030\003 \001(\002\022.\n"
-    "\016layerDataBlock\030\004 \003(\0132\026.stream.LayerData"
-    "Block\022\016\n\006result\030\005 \001(\010\"\266\001\n\016LayerDataBlock"
-    "\022\021\n\telementId\030\001 \001(\005\022\026\n\016elementParamId\030\002 "
-    "\001(\005\022\021\n\tblockType\030\003 \001(\r\022*\n\tvecBlocks\030\004 \003("
-    "\0132\027.stream.VectorDataBlock\022+\n\013chainBlock"
-    "s\030\005 \003(\0132\026.stream.ChainDataBlock\022\r\n\005order"
-    "\030\006 \001(\r\"M\n\017VectorDataBlock\022\016\n\006startX\030\001 \001("
-    "\002\022\016\n\006startY\030\002 \001(\002\022\014\n\004endX\030\003 \001(\002\022\014\n\004endY\030"
-    "\004 \001(\002\"A\n\016ChainDataBlock\022\016\n\006dotNum\030\001 \001(\r\022"
-    "\037\n\010pointVec\030\002 \003(\0132\r.stream.Point\"#\n\005Poin"
-    "t\022\014\n\004xPos\030\001 \001(\002\022\014\n\004yPos\030\002 \001(\002\"\033\n\013RegResp"
-    "once\022\014\n\004data\030\001 \001(\005\"D\n\017ImgInfoResponce\022\022\n"
-    "\nlevelImage\030\001 \001(\r\022\r\n\005width\030\002 \001(\005\022\016\n\006heig"
-    "ht\030\003 \001(\005\"\033\n\013ComResponce\022\014\n\004data\030\001 \001(\014*\223\001"
-    "\n\004TYPE\022\t\n\005iBOOL\020\000\022\n\n\006iSHORT\020\001\022\013\n\007iUSHORT"
-    "\020\002\022\010\n\004iINT\020\003\022\t\n\005iUINT\020\004\022\n\n\006iFLOAT\020\005\022\013\n\007i"
-    "STRING\020\006\022\t\n\005iCHAR\020\007\022\n\n\006iUCHAR\020\010\022\t\n\005iWORD"
-    "\020\t\022\013\n\007iDOUBLE\020\n\022\n\n\006iTIMET\020\013**\n\nDATAHANDL"
-    "E\022\n\n\006UPDATE\020\000\022\007\n\003ADD\020\001\022\007\n\003DEL\020\0022\372\001\n\006Stre"
-    "am\0224\n\006Simple\022\023.stream.RequestInfo\032\023.stre"
-    "am.ResponseAny\"\000\022=\n\014ServerStream\022\023.strea"
-    "m.RequestInfo\032\024.stream.ResponseInfo\"\0000\001\022"
-    "=\n\014ClientStream\022\023.stream.RequestInfo\032\024.s"
-    "tream.ResponseInfo\"\000(\001\022<\n\tAllStream\022\023.st"
-    "ream.RequestInfo\032\024.stream.ResponseInfo\"\000"
-    "(\0010\001B-\n\027io.grpc.examples.streamB\013StreamP"
-    "rotoP\001\242\002\002STb\006proto3"
+    "\006powder\030\n \001(\002\022\r\n\005seqNo\030\013 \001(\005\022\021\n\tcontrolN"
+    "o\030\014 \001(\005\022\020\n\010serialNo\030\r \001(\005\022\023\n\013controlType"
+    "\030\016 \001(\005\022\020\n\010cardName\030\017 \001(\014\022\016\n\006cardIP\030\020 \001(\014"
+    "\022\021\n\thadAssign\030\021 \001(\010\022\020\n\010hadMatch\030\022 \001(\010\"\254\001"
+    "\n\013RequestInfo\022\020\n\010dataType\030\001 \001(\r\022\017\n\007nameK"
+    "ey\030\002 \001(\014\022\020\n\010strValue\030\003 \001(\014\022\037\n\tvalueType\030"
+    "\004 \001(\0162\014.stream.TYPE\022&\n\nhandleType\030\005 \001(\0162"
+    "\022.stream.DATAHANDLE\022\037\n\004item\030\006 \003(\0132\021.stre"
+    "am.ParamInfo\"Q\n\014ResponseInfo\022\020\n\010dataType"
+    "\030\001 \001(\r\022\016\n\006result\030\002 \001(\010\022\037\n\004item\030\003 \003(\0132\021.s"
+    "tream.ParamInfo\"1\n\013ResponseAny\022\"\n\004data\030\001"
+    " \001(\0132\024.google.protobuf.Any\"\210\001\n\tLayerData"
+    "\022\023\n\013zCooldinate\030\001 \001(\002\022\016\n\006powder\030\002 \001(\002\022\026\n"
+    "\016layerThickness\030\003 \001(\002\022.\n\016layerDataBlock\030"
+    "\004 \003(\0132\026.stream.LayerDataBlock\022\016\n\006result\030"
+    "\005 \001(\010\"\266\001\n\016LayerDataBlock\022\021\n\telementId\030\001 "
+    "\001(\005\022\026\n\016elementParamId\030\002 \001(\005\022\021\n\tblockType"
+    "\030\003 \001(\r\022*\n\tvecBlocks\030\004 \003(\0132\027.stream.Vecto"
+    "rDataBlock\022+\n\013chainBlocks\030\005 \003(\0132\026.stream"
+    ".ChainDataBlock\022\r\n\005order\030\006 \001(\r\"M\n\017Vector"
+    "DataBlock\022\016\n\006startX\030\001 \001(\002\022\016\n\006startY\030\002 \001("
+    "\002\022\014\n\004endX\030\003 \001(\002\022\014\n\004endY\030\004 \001(\002\"A\n\016ChainDa"
+    "taBlock\022\016\n\006dotNum\030\001 \001(\r\022\037\n\010pointVec\030\002 \003("
+    "\0132\r.stream.Point\"#\n\005Point\022\014\n\004xPos\030\001 \001(\002\022"
+    "\014\n\004yPos\030\002 \001(\002\"\033\n\013RegResponce\022\014\n\004data\030\001 \001"
+    "(\005\"D\n\017ImgInfoResponce\022\022\n\nlevelImage\030\001 \001("
+    "\r\022\r\n\005width\030\002 \001(\005\022\016\n\006height\030\003 \001(\005\"\033\n\013ComR"
+    "esponce\022\014\n\004data\030\001 \001(\014\"D\n\022ScannerCrtlCfgR"
+    "esp\022.\n\nscannerCfg\030\001 \003(\0132\032.stream.Scanner"
+    "CrtlCfgData\"\210\005\n\022ScannerCrtlCfgData\022\r\n\005se"
+    "qNo\030\001 \001(\005\022*\n\014fixPointData\030\002 \003(\0132\024.stream"
+    ".FixPointData\022*\n\014scanParamCfg\030\003 \001(\0132\024.st"
+    "ream.ScanParamCfg\022,\n\016hatchingParams\030\004 \001("
+    "\0132\024.stream.ScanParamCfg\022*\n\014borderParams\030"
+    "\005 \001(\0132\024.stream.ScanParamCfg\022+\n\rsupportPa"
+    "rams\030\006 \001(\0132\024.stream.ScanParamCfg\0220\n\017corr"
+    "ectParamCfg\030\007 \001(\0132\027.stream.CorrectParamC"
+    "fg\022(\n\013scanTestCfg\030\010 \001(\0132\023.stream.ScanTes"
+    "tCfg\022,\n\rskyWritingCfg\030\t \001(\0132\025.stream.Sky"
+    "WritingCfg\0220\n\017powerCompensate\030\n \003(\0132\027.st"
+    "ream.PowerCompensate\0225\n\020tPowerCompensate"
+    "\030\013 \003(\0132\033.stream.TimePowerCompensate\022\021\n\tc"
+    "ontrolNo\030\014 \001(\005\022\020\n\010serialNo\030\r \001(\005\022\023\n\013cont"
+    "rolType\030\016 \001(\005\022\020\n\010cardName\030\017 \001(\014\022\016\n\006cardI"
+    "P\030\020 \001(\014\022\020\n\010isEnable\030\021 \001(\010\022\021\n\thadAssign\030\022"
+    " \001(\010\022\020\n\010hadMatch\030\023 \001(\010\"Y\n\014FixPointData\022\n"
+    "\n\002id\030\001 \001(\005\022\013\n\003cno\030\002 \001(\005\022\016\n\006pointX\030\003 \001(\002\022"
+    "\016\n\006pointY\030\004 \001(\002\022\020\n\010duration\030\005 \001(\r\"\275\005\n\014Sc"
+    "anParamCfg\022\021\n\tedgeLevel\030\001 \001(\005\022\024\n\014edgeLev"
+    "elMin\030\002 \001(\005\022\024\n\014edgeLevelMax\030\003 \001(\005\022\021\n\tjum"
+    "pDelay\030\004 \001(\r\022\024\n\014jumpDelayMin\030\005 \001(\r\022\024\n\014ju"
+    "mpDelayMax\030\006 \001(\r\022\021\n\tscanDelay\030\007 \001(\r\022\024\n\014s"
+    "canDelayMin\030\010 \001(\r\022\024\n\014scanDelayMax\030\t \001(\r\022"
+    "\024\n\014polygonDelay\030\n \001(\r\022\027\n\017polygonDelayMin"
+    "\030\013 \001(\r\022\027\n\017polygonDelayMax\030\014 \001(\r\022\025\n\rlaser"
+    "offDelay\030\r \001(\003\022\030\n\020laseroffDelayMin\030\016 \001(\003"
+    "\022\030\n\020laseroffDelayMax\030\017 \001(\003\022\024\n\014laseronDel"
+    "ay\030\020 \001(\003\022\027\n\017laseronDelayMin\030\021 \001(\003\022\027\n\017las"
+    "eronDelayMax\030\022 \001(\003\022\024\n\014minJumpDelay\030\023 \001(\r"
+    "\022\027\n\017minJumpDelayMin\030\024 \001(\r\022\027\n\017minJumpDela"
+    "yMax\030\025 \001(\r\022\027\n\017jumpLengthLimit\030\026 \001(\r\022\032\n\022j"
+    "umpLengthLimitMin\030\027 \001(\r\022\032\n\022jumpLengthLim"
+    "itMax\030\030 \001(\r\022\021\n\tjumpSpeed\030\031 \001(\001\022\024\n\014jumpSp"
+    "eedMin\030\032 \001(\001\022\024\n\014jumpSpeedMax\030\033 \001(\001\022\021\n\tma"
+    "rkSpeed\030\034 \001(\001\022\024\n\014markSpeedMin\030\035 \001(\001\022\024\n\014m"
+    "arkSpeedMax\030\036 \001(\001\"\256\004\n\017CorrectParamCfg\022\023\n"
+    "\013xmeasureMin\030\001 \001(\001\022\023\n\013xmeasureMax\030\002 \001(\001\022"
+    "\023\n\013ymeasureMin\030\003 \001(\001\022\023\n\013ymeasureMax\030\004 \001("
+    "\001\022\017\n\007xposfix\030\005 \001(\001\022\017\n\007yposfix\030\006 \001(\001\022\021\n\ts"
+    "canAngle\030\007 \001(\001\022\024\n\014scanAngleMin\030\010 \001(\001\022\024\n\014"
+    "scanAngleMax\030\t \001(\001\022\020\n\010fixAngle\030\n \001(\001\022\023\n\013"
+    "fixAngleMin\030\013 \001(\001\022\023\n\013fixAngleMax\030\014 \001(\001\022\020"
+    "\n\010xcorrect\030\r \001(\001\022\020\n\010ycorrect\030\016 \001(\001\022\023\n\013xc"
+    "orrectMin\030\017 \001(\001\022\023\n\013xcorrectMax\030\020 \001(\001\022\023\n\013"
+    "ycorrectMin\030\021 \001(\001\022\023\n\013ycorrectMax\030\022 \001(\001\022\023"
+    "\n\013realXOffset\030\023 \001(\001\022\023\n\013realYOffset\030\024 \001(\001"
+    "\022\017\n\007factorK\030\025 \001(\001\022\027\n\017isCorrectFile3D\030\026 \001"
+    "(\010\022\026\n\016isDynamicFocus\030\027 \001(\010\022\024\n\014defocusRat"
+    "io\030\030 \001(\001\022\027\n\017defocusRatioMin\030\031 \001(\001\022\027\n\017def"
+    "ocusRatioMax\030\032 \001(\001\"\226\004\n\013ScanTestCfg\022\022\n\nde"
+    "bugShape\030\001 \001(\005\022\021\n\tshapeSize\030\002 \001(\005\022\024\n\014sha"
+    "peSizeMin\030\003 \001(\005\022\026\n\016shape_size_max\030\004 \001(\005\022"
+    "\023\n\013laser_power\030\005 \001(\005\022\027\n\017laser_power_min\030"
+    "\006 \001(\005\022\027\n\017laser_power_max\030\007 \001(\005\022\017\n\007defocu"
+    "s\030\010 \001(\001\022\023\n\013defocus_min\030\t \001(\001\022\023\n\013defocus_"
+    "max\030\n \001(\001\022\020\n\010is_cycle\030\013 \001(\010\022\017\n\007cross_x\030\014"
+    " \001(\001\022\017\n\007cross_y\030\r \001(\001\022\022\n\nz_distance\030\016 \001("
+    "\001\022\034\n\024isAutoHeatingScanner\030\017 \001(\010\022!\n\031autoH"
+    "eatingScannerMinutes\030\020 \001(\r\022\036\n\026autoHeatin"
+    "gScannerSize\030\021 \001(\r\022\037\n\027autoHeatingScanner"
+    "Speed\030\022 \001(\001\022\031\n\021mark_test_start_x\030\023 \001(\001\022\031"
+    "\n\021mark_test_start_y\030\024 \001(\001\022\027\n\017mark_test_e"
+    "nd_x\030\025 \001(\001\022\027\n\017mark_test_end_y\030\026 \001(\001\"\314\002\n\r"
+    "SkyWritingCfg\022\020\n\010isEnable\030\001 \001(\010\022\017\n\007timel"
+    "ag\030\002 \001(\001\022\022\n\ntimelagMin\030\003 \001(\001\022\022\n\ntimelagM"
+    "ax\030\004 \001(\001\022\024\n\014laserOnShift\030\005 \001(\003\022\027\n\017laserO"
+    "nShiftMin\030\006 \001(\003\022\027\n\017laserOnShiftMax\030\007 \001(\003"
+    "\022\r\n\005nprev\030\010 \001(\r\022\020\n\010nprevMin\030\t \001(\r\022\020\n\010npr"
+    "evMax\030\n \001(\r\022\r\n\005npost\030\013 \001(\r\022\020\n\010npostMin\030\014"
+    " \001(\r\022\020\n\010npostMax\030\r \001(\r\022\014\n\004mode\030\016 \001(\005\022\016\n\006"
+    "limite\030\017 \001(\001\022\021\n\tlimiteMin\030\020 \001(\001\022\021\n\tlimit"
+    "eMax\030\021 \001(\001\"d\n\017PowerCompensate\022\013\n\003cno\030\001 \001"
+    "(\005\022\017\n\007percent\030\002 \001(\005\022\r\n\005value\030\003 \001(\002\022\021\n\tva"
+    "lue_min\030\004 \001(\002\022\021\n\tvalue_max\030\005 \001(\002\"j\n\023Time"
+    "PowerCompensate\022\n\n\002id\030\001 \001(\005\022\013\n\003cno\030\002 \001(\005"
+    "\022\023\n\013startMinute\030\003 \001(\r\022\021\n\tendMinute\030\004 \001(\r"
+    "\022\022\n\ncompensate\030\005 \001(\002*\223\001\n\004TYPE\022\t\n\005iBOOL\020\000"
+    "\022\n\n\006iSHORT\020\001\022\013\n\007iUSHORT\020\002\022\010\n\004iINT\020\003\022\t\n\005i"
+    "UINT\020\004\022\n\n\006iFLOAT\020\005\022\013\n\007iSTRING\020\006\022\t\n\005iCHAR"
+    "\020\007\022\n\n\006iUCHAR\020\010\022\t\n\005iWORD\020\t\022\013\n\007iDOUBLE\020\n\022\n"
+    "\n\006iTIMET\020\013**\n\nDATAHANDLE\022\n\n\006UPDATE\020\000\022\007\n\003"
+    "ADD\020\001\022\007\n\003DEL\020\0022\372\001\n\006Stream\0224\n\006Simple\022\023.st"
+    "ream.RequestInfo\032\023.stream.ResponseAny\"\000\022"
+    "=\n\014ServerStream\022\023.stream.RequestInfo\032\024.s"
+    "tream.ResponseInfo\"\0000\001\022=\n\014ClientStream\022\023"
+    ".stream.RequestInfo\032\024.stream.ResponseInf"
+    "o\"\000(\001\022<\n\tAllStream\022\023.stream.RequestInfo\032"
+    "\024.stream.ResponseInfo\"\000(\0010\001B-\n\027io.grpc.e"
+    "xamples.streamB\013StreamProtoP\001\242\002\002STb\006prot"
+    "o3"
 };
 static const ::_pbi::DescriptorTable* const descriptor_table_stream_2eproto_deps[1] =
     {
@@ -497,13 +1113,13 @@ static ::absl::once_flag descriptor_table_stream_2eproto_once;
 const ::_pbi::DescriptorTable descriptor_table_stream_2eproto = {
     false,
     false,
-    1699,
+    5002,
     descriptor_table_protodef_stream_2eproto,
     "stream.proto",
     &descriptor_table_stream_2eproto_once,
     descriptor_table_stream_2eproto_deps,
     1,
-    12,
+    21,
     schemas,
     file_default_instances,
     TableStruct_stream_2eproto::offsets,
@@ -585,13 +1201,21 @@ ParamInfo::ParamInfo(const ParamInfo& from) : ::google::protobuf::Message() {
       decltype(_impl_.namekey_){},
       decltype(_impl_.strvalue_){},
       decltype(_impl_.context_){},
+      decltype(_impl_.cardname_){},
+      decltype(_impl_.cardip_){},
       decltype(_impl_.valuetype_){},
+      decltype(_impl_.startlayer_){},
       decltype(_impl_.isenable_){},
       decltype(_impl_.isalarm_){},
       decltype(_impl_.isshow_){},
-      decltype(_impl_.startlayer_){},
+      decltype(_impl_.hadassign_){},
       decltype(_impl_.endlayer_){},
       decltype(_impl_.powder_){},
+      decltype(_impl_.seqno_){},
+      decltype(_impl_.controlno_){},
+      decltype(_impl_.serialno_){},
+      decltype(_impl_.controltype_){},
+      decltype(_impl_.hadmatch_){},
       /*decltype(_impl_._cached_size_)*/ {},
   };
   _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
@@ -617,9 +1241,23 @@ ParamInfo::ParamInfo(const ParamInfo& from) : ::google::protobuf::Message() {
   if (!from._internal_context().empty()) {
     _this->_impl_.context_.Set(from._internal_context(), _this->GetArenaForAllocation());
   }
+  _impl_.cardname_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        _impl_.cardname_.Set("", GetArenaForAllocation());
+  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (!from._internal_cardname().empty()) {
+    _this->_impl_.cardname_.Set(from._internal_cardname(), _this->GetArenaForAllocation());
+  }
+  _impl_.cardip_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        _impl_.cardip_.Set("", GetArenaForAllocation());
+  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (!from._internal_cardip().empty()) {
+    _this->_impl_.cardip_.Set(from._internal_cardip(), _this->GetArenaForAllocation());
+  }
   ::memcpy(&_impl_.valuetype_, &from._impl_.valuetype_,
-    static_cast<::size_t>(reinterpret_cast<char*>(&_impl_.powder_) -
-    reinterpret_cast<char*>(&_impl_.valuetype_)) + sizeof(_impl_.powder_));
+    static_cast<::size_t>(reinterpret_cast<char*>(&_impl_.hadmatch_) -
+    reinterpret_cast<char*>(&_impl_.valuetype_)) + sizeof(_impl_.hadmatch_));
 
   // @@protoc_insertion_point(copy_constructor:stream.ParamInfo)
 }
@@ -629,13 +1267,21 @@ inline void ParamInfo::SharedCtor(::_pb::Arena* arena) {
       decltype(_impl_.namekey_){},
       decltype(_impl_.strvalue_){},
       decltype(_impl_.context_){},
+      decltype(_impl_.cardname_){},
+      decltype(_impl_.cardip_){},
       decltype(_impl_.valuetype_){0},
+      decltype(_impl_.startlayer_){0},
       decltype(_impl_.isenable_){false},
       decltype(_impl_.isalarm_){false},
       decltype(_impl_.isshow_){false},
-      decltype(_impl_.startlayer_){0},
+      decltype(_impl_.hadassign_){false},
       decltype(_impl_.endlayer_){0},
       decltype(_impl_.powder_){0},
+      decltype(_impl_.seqno_){0},
+      decltype(_impl_.controlno_){0},
+      decltype(_impl_.serialno_){0},
+      decltype(_impl_.controltype_){0},
+      decltype(_impl_.hadmatch_){false},
       /*decltype(_impl_._cached_size_)*/ {},
   };
   _impl_.namekey_.InitDefault();
@@ -650,6 +1296,14 @@ inline void ParamInfo::SharedCtor(::_pb::Arena* arena) {
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
         _impl_.context_.Set("", GetArenaForAllocation());
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.cardname_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        _impl_.cardname_.Set("", GetArenaForAllocation());
+  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.cardip_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        _impl_.cardip_.Set("", GetArenaForAllocation());
+  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
 }
 ParamInfo::~ParamInfo() {
   // @@protoc_insertion_point(destructor:stream.ParamInfo)
@@ -661,6 +1315,8 @@ inline void ParamInfo::SharedDtor() {
   _impl_.namekey_.Destroy();
   _impl_.strvalue_.Destroy();
   _impl_.context_.Destroy();
+  _impl_.cardname_.Destroy();
+  _impl_.cardip_.Destroy();
 }
 void ParamInfo::SetCachedSize(int size) const {
   _impl_._cached_size_.Set(size);
@@ -675,9 +1331,11 @@ PROTOBUF_NOINLINE void ParamInfo::Clear() {
   _impl_.namekey_.ClearToEmpty();
   _impl_.strvalue_.ClearToEmpty();
   _impl_.context_.ClearToEmpty();
+  _impl_.cardname_.ClearToEmpty();
+  _impl_.cardip_.ClearToEmpty();
   ::memset(&_impl_.valuetype_, 0, static_cast<::size_t>(
-      reinterpret_cast<char*>(&_impl_.powder_) -
-      reinterpret_cast<char*>(&_impl_.valuetype_)) + sizeof(_impl_.powder_));
+      reinterpret_cast<char*>(&_impl_.hadmatch_) -
+      reinterpret_cast<char*>(&_impl_.valuetype_)) + sizeof(_impl_.hadmatch_));
   _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
 }
 
@@ -689,15 +1347,15 @@ const char* ParamInfo::_InternalParse(
 
 
 PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
-const ::_pbi::TcParseTable<4, 10, 0, 0, 2> ParamInfo::_table_ = {
+const ::_pbi::TcParseTable<5, 18, 0, 0, 2> ParamInfo::_table_ = {
   {
     0,  // no _has_bits_
     0, // no _extensions_
-    10, 120,  // max_field_number, fast_idx_mask
+    18, 248,  // max_field_number, fast_idx_mask
     offsetof(decltype(_table_), field_lookup_table),
-    4294966272,  // skipmap
+    4294705152,  // skipmap
     offsetof(decltype(_table_), field_entries),
-    10,  // num_field_entries
+    18,  // num_field_entries
     0,  // num_aux_entries
     offsetof(decltype(_table_), field_names),  // no aux_entries
     &_ParamInfo_default_instance_._instance,
@@ -734,6 +1392,38 @@ const ::_pbi::TcParseTable<4, 10, 0, 0, 2> ParamInfo::_table_ = {
     // float powder = 10;
     {::_pbi::TcParser::FastF32S1,
      {85, 63, 0, PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.powder_)}},
+    // int32 seqNo = 11;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ParamInfo, _impl_.seqno_), 63>(),
+     {88, 63, 0, PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.seqno_)}},
+    // int32 controlNo = 12;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ParamInfo, _impl_.controlno_), 63>(),
+     {96, 63, 0, PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.controlno_)}},
+    // int32 serialNo = 13;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ParamInfo, _impl_.serialno_), 63>(),
+     {104, 63, 0, PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.serialno_)}},
+    // int32 controlType = 14;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ParamInfo, _impl_.controltype_), 63>(),
+     {112, 63, 0, PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.controltype_)}},
+    // bytes cardName = 15;
+    {::_pbi::TcParser::FastBS1,
+     {122, 63, 0, PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.cardname_)}},
+    // bytes cardIP = 16;
+    {::_pbi::TcParser::FastBS2,
+     {386, 63, 0, PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.cardip_)}},
+    // bool hadAssign = 17;
+    {::_pbi::TcParser::FastV8S2,
+     {392, 63, 0, PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.hadassign_)}},
+    // bool hadMatch = 18;
+    {::_pbi::TcParser::FastV8S2,
+     {400, 63, 0, PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.hadmatch_)}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
     {::_pbi::TcParser::MiniParse, {}},
     {::_pbi::TcParser::MiniParse, {}},
     {::_pbi::TcParser::MiniParse, {}},
@@ -772,6 +1462,30 @@ const ::_pbi::TcParseTable<4, 10, 0, 0, 2> ParamInfo::_table_ = {
     // float powder = 10;
     {PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.powder_), 0, 0,
     (0 | ::_fl::kFcSingular | ::_fl::kFloat)},
+    // int32 seqNo = 11;
+    {PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.seqno_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt32)},
+    // int32 controlNo = 12;
+    {PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.controlno_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt32)},
+    // int32 serialNo = 13;
+    {PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.serialno_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt32)},
+    // int32 controlType = 14;
+    {PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.controltype_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt32)},
+    // bytes cardName = 15;
+    {PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.cardname_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)},
+    // bytes cardIP = 16;
+    {PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.cardip_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)},
+    // bool hadAssign = 17;
+    {PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.hadassign_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kBool)},
+    // bool hadMatch = 18;
+    {PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.hadmatch_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kBool)},
   }},
   // no aux_entries
   {{
@@ -857,6 +1571,60 @@ const ::_pbi::TcParseTable<4, 10, 0, 0, 2> ParamInfo::_table_ = {
         10, this->_internal_powder(), target);
   }
 
+  // int32 seqNo = 11;
+  if (this->_internal_seqno() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt32ToArrayWithField<11>(
+            stream, this->_internal_seqno(), target);
+  }
+
+  // int32 controlNo = 12;
+  if (this->_internal_controlno() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt32ToArrayWithField<12>(
+            stream, this->_internal_controlno(), target);
+  }
+
+  // int32 serialNo = 13;
+  if (this->_internal_serialno() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt32ToArrayWithField<13>(
+            stream, this->_internal_serialno(), target);
+  }
+
+  // int32 controlType = 14;
+  if (this->_internal_controltype() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt32ToArrayWithField<14>(
+            stream, this->_internal_controltype(), target);
+  }
+
+  // bytes cardName = 15;
+  if (!this->_internal_cardname().empty()) {
+    const std::string& _s = this->_internal_cardname();
+    target = stream->WriteBytesMaybeAliased(15, _s, target);
+  }
+
+  // bytes cardIP = 16;
+  if (!this->_internal_cardip().empty()) {
+    const std::string& _s = this->_internal_cardip();
+    target = stream->WriteBytesMaybeAliased(16, _s, target);
+  }
+
+  // bool hadAssign = 17;
+  if (this->_internal_hadassign() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(
+        17, this->_internal_hadassign(), target);
+  }
+
+  // bool hadMatch = 18;
+  if (this->_internal_hadmatch() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(
+        18, this->_internal_hadmatch(), target);
+  }
+
   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
     target =
         ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
@@ -892,12 +1660,30 @@ const ::_pbi::TcParseTable<4, 10, 0, 0, 2> ParamInfo::_table_ = {
                                     this->_internal_context());
   }
 
+  // bytes cardName = 15;
+  if (!this->_internal_cardname().empty()) {
+    total_size += 1 + ::google::protobuf::internal::WireFormatLite::BytesSize(
+                                    this->_internal_cardname());
+  }
+
+  // bytes cardIP = 16;
+  if (!this->_internal_cardip().empty()) {
+    total_size += 2 + ::google::protobuf::internal::WireFormatLite::BytesSize(
+                                    this->_internal_cardip());
+  }
+
   // .stream.TYPE valueType = 3;
   if (this->_internal_valuetype() != 0) {
     total_size += 1 +
                   ::_pbi::WireFormatLite::EnumSize(this->_internal_valuetype());
   }
 
+  // int32 startLayer = 8;
+  if (this->_internal_startlayer() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
+        this->_internal_startlayer());
+  }
+
   // bool isEnable = 5;
   if (this->_internal_isenable() != 0) {
     total_size += 2;
@@ -913,10 +1699,9 @@ const ::_pbi::TcParseTable<4, 10, 0, 0, 2> ParamInfo::_table_ = {
     total_size += 2;
   }
 
-  // int32 startLayer = 8;
-  if (this->_internal_startlayer() != 0) {
-    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
-        this->_internal_startlayer());
+  // bool hadAssign = 17;
+  if (this->_internal_hadassign() != 0) {
+    total_size += 3;
   }
 
   // int32 endLayer = 9;
@@ -935,6 +1720,35 @@ const ::_pbi::TcParseTable<4, 10, 0, 0, 2> ParamInfo::_table_ = {
     total_size += 5;
   }
 
+  // int32 seqNo = 11;
+  if (this->_internal_seqno() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
+        this->_internal_seqno());
+  }
+
+  // int32 controlNo = 12;
+  if (this->_internal_controlno() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
+        this->_internal_controlno());
+  }
+
+  // int32 serialNo = 13;
+  if (this->_internal_serialno() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
+        this->_internal_serialno());
+  }
+
+  // int32 controlType = 14;
+  if (this->_internal_controltype() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
+        this->_internal_controltype());
+  }
+
+  // bool hadMatch = 18;
+  if (this->_internal_hadmatch() != 0) {
+    total_size += 3;
+  }
+
   return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
 }
 
@@ -962,9 +1776,18 @@ void ParamInfo::MergeImpl(::google::protobuf::Message& to_msg, const ::google::p
   if (!from._internal_context().empty()) {
     _this->_internal_set_context(from._internal_context());
   }
+  if (!from._internal_cardname().empty()) {
+    _this->_internal_set_cardname(from._internal_cardname());
+  }
+  if (!from._internal_cardip().empty()) {
+    _this->_internal_set_cardip(from._internal_cardip());
+  }
   if (from._internal_valuetype() != 0) {
     _this->_internal_set_valuetype(from._internal_valuetype());
   }
+  if (from._internal_startlayer() != 0) {
+    _this->_internal_set_startlayer(from._internal_startlayer());
+  }
   if (from._internal_isenable() != 0) {
     _this->_internal_set_isenable(from._internal_isenable());
   }
@@ -974,8 +1797,8 @@ void ParamInfo::MergeImpl(::google::protobuf::Message& to_msg, const ::google::p
   if (from._internal_isshow() != 0) {
     _this->_internal_set_isshow(from._internal_isshow());
   }
-  if (from._internal_startlayer() != 0) {
-    _this->_internal_set_startlayer(from._internal_startlayer());
+  if (from._internal_hadassign() != 0) {
+    _this->_internal_set_hadassign(from._internal_hadassign());
   }
   if (from._internal_endlayer() != 0) {
     _this->_internal_set_endlayer(from._internal_endlayer());
@@ -988,6 +1811,21 @@ void ParamInfo::MergeImpl(::google::protobuf::Message& to_msg, const ::google::p
   if (raw_powder != 0) {
     _this->_internal_set_powder(from._internal_powder());
   }
+  if (from._internal_seqno() != 0) {
+    _this->_internal_set_seqno(from._internal_seqno());
+  }
+  if (from._internal_controlno() != 0) {
+    _this->_internal_set_controlno(from._internal_controlno());
+  }
+  if (from._internal_serialno() != 0) {
+    _this->_internal_set_serialno(from._internal_serialno());
+  }
+  if (from._internal_controltype() != 0) {
+    _this->_internal_set_controltype(from._internal_controltype());
+  }
+  if (from._internal_hadmatch() != 0) {
+    _this->_internal_set_hadmatch(from._internal_hadmatch());
+  }
   _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_);
 }
 
@@ -1013,9 +1851,13 @@ void ParamInfo::InternalSwap(ParamInfo* other) {
                                        &other->_impl_.strvalue_, rhs_arena);
   ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.context_, lhs_arena,
                                        &other->_impl_.context_, rhs_arena);
+  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.cardname_, lhs_arena,
+                                       &other->_impl_.cardname_, rhs_arena);
+  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.cardip_, lhs_arena,
+                                       &other->_impl_.cardip_, rhs_arena);
   ::google::protobuf::internal::memswap<
-      PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.powder_)
-      + sizeof(ParamInfo::_impl_.powder_)
+      PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.hadmatch_)
+      + sizeof(ParamInfo::_impl_.hadmatch_)
       - PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.valuetype_)>(
           reinterpret_cast<char*>(&_impl_.valuetype_),
           reinterpret_cast<char*>(&other->_impl_.valuetype_));
@@ -3722,6 +4564,5342 @@ void ComResponce::InternalSwap(ComResponce* other) {
       &descriptor_table_stream_2eproto_getter, &descriptor_table_stream_2eproto_once,
       file_level_metadata_stream_2eproto[11]);
 }
+// ===================================================================
+
+class ScannerCrtlCfgResp::_Internal {
+ public:
+};
+
+ScannerCrtlCfgResp::ScannerCrtlCfgResp(::google::protobuf::Arena* arena)
+    : ::google::protobuf::Message(arena) {
+  SharedCtor(arena);
+  // @@protoc_insertion_point(arena_constructor:stream.ScannerCrtlCfgResp)
+}
+ScannerCrtlCfgResp::ScannerCrtlCfgResp(const ScannerCrtlCfgResp& from) : ::google::protobuf::Message() {
+  ScannerCrtlCfgResp* const _this = this;
+  (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_.scannercfg_){from._impl_.scannercfg_},
+      /*decltype(_impl_._cached_size_)*/ {},
+  };
+  _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
+      from._internal_metadata_);
+
+  // @@protoc_insertion_point(copy_constructor:stream.ScannerCrtlCfgResp)
+}
+inline void ScannerCrtlCfgResp::SharedCtor(::_pb::Arena* arena) {
+  (void)arena;
+  new (&_impl_) Impl_{
+      decltype(_impl_.scannercfg_){arena},
+      /*decltype(_impl_._cached_size_)*/ {},
+  };
+}
+ScannerCrtlCfgResp::~ScannerCrtlCfgResp() {
+  // @@protoc_insertion_point(destructor:stream.ScannerCrtlCfgResp)
+  _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
+  SharedDtor();
+}
+inline void ScannerCrtlCfgResp::SharedDtor() {
+  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.scannercfg_.~RepeatedPtrField();
+}
+void ScannerCrtlCfgResp::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+PROTOBUF_NOINLINE void ScannerCrtlCfgResp::Clear() {
+// @@protoc_insertion_point(message_clear_start:stream.ScannerCrtlCfgResp)
+  ::uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _internal_mutable_scannercfg()->Clear();
+  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
+}
+
+const char* ScannerCrtlCfgResp::_InternalParse(
+    const char* ptr, ::_pbi::ParseContext* ctx) {
+  ptr = ::_pbi::TcParser::ParseLoop(this, ptr, ctx, &_table_.header);
+  return ptr;
+}
+
+
+PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
+const ::_pbi::TcParseTable<0, 1, 1, 0, 2> ScannerCrtlCfgResp::_table_ = {
+  {
+    0,  // no _has_bits_
+    0, // no _extensions_
+    1, 0,  // max_field_number, fast_idx_mask
+    offsetof(decltype(_table_), field_lookup_table),
+    4294967294,  // skipmap
+    offsetof(decltype(_table_), field_entries),
+    1,  // num_field_entries
+    1,  // num_aux_entries
+    offsetof(decltype(_table_), aux_entries),
+    &_ScannerCrtlCfgResp_default_instance_._instance,
+    ::_pbi::TcParser::GenericFallback,  // fallback
+  }, {{
+    // repeated .stream.ScannerCrtlCfgData scannerCfg = 1;
+    {::_pbi::TcParser::FastMtR1,
+     {10, 63, 0, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgResp, _impl_.scannercfg_)}},
+  }}, {{
+    65535, 65535
+  }}, {{
+    // repeated .stream.ScannerCrtlCfgData scannerCfg = 1;
+    {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgResp, _impl_.scannercfg_), 0, 0,
+    (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)},
+  }}, {{
+    {::_pbi::TcParser::GetTable<::stream::ScannerCrtlCfgData>()},
+  }}, {{
+  }},
+};
+
+::uint8_t* ScannerCrtlCfgResp::_InternalSerialize(
+    ::uint8_t* target,
+    ::google::protobuf::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:stream.ScannerCrtlCfgResp)
+  ::uint32_t cached_has_bits = 0;
+  (void)cached_has_bits;
+
+  // repeated .stream.ScannerCrtlCfgData scannerCfg = 1;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_scannercfg_size()); i < n; i++) {
+    const auto& repfield = this->_internal_scannercfg().Get(i);
+    target = ::google::protobuf::internal::WireFormatLite::
+        InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target =
+        ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
+            _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:stream.ScannerCrtlCfgResp)
+  return target;
+}
+
+::size_t ScannerCrtlCfgResp::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:stream.ScannerCrtlCfgResp)
+  ::size_t total_size = 0;
+
+  ::uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .stream.ScannerCrtlCfgData scannerCfg = 1;
+  total_size += 1UL * this->_internal_scannercfg_size();
+  for (const auto& msg : this->_internal_scannercfg()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSize(msg);
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::google::protobuf::Message::ClassData ScannerCrtlCfgResp::_class_data_ = {
+    ::google::protobuf::Message::CopyWithSourceCheck,
+    ScannerCrtlCfgResp::MergeImpl
+};
+const ::google::protobuf::Message::ClassData*ScannerCrtlCfgResp::GetClassData() const { return &_class_data_; }
+
+
+void ScannerCrtlCfgResp::MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg) {
+  auto* const _this = static_cast<ScannerCrtlCfgResp*>(&to_msg);
+  auto& from = static_cast<const ScannerCrtlCfgResp&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:stream.ScannerCrtlCfgResp)
+  ABSL_DCHECK_NE(&from, _this);
+  ::uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_internal_mutable_scannercfg()->MergeFrom(from._internal_scannercfg());
+  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ScannerCrtlCfgResp::CopyFrom(const ScannerCrtlCfgResp& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:stream.ScannerCrtlCfgResp)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+PROTOBUF_NOINLINE bool ScannerCrtlCfgResp::IsInitialized() const {
+  return true;
+}
+
+void ScannerCrtlCfgResp::InternalSwap(ScannerCrtlCfgResp* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  _impl_.scannercfg_.InternalSwap(&other->_impl_.scannercfg_);
+}
+
+::google::protobuf::Metadata ScannerCrtlCfgResp::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_stream_2eproto_getter, &descriptor_table_stream_2eproto_once,
+      file_level_metadata_stream_2eproto[12]);
+}
+// ===================================================================
+
+class ScannerCrtlCfgData::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ScannerCrtlCfgData>()._impl_._has_bits_);
+  static constexpr ::int32_t kHasBitsOffset =
+    8 * PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_._has_bits_);
+  static const ::stream::ScanParamCfg& scanparamcfg(const ScannerCrtlCfgData* msg);
+  static void set_has_scanparamcfg(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static const ::stream::ScanParamCfg& hatchingparams(const ScannerCrtlCfgData* msg);
+  static void set_has_hatchingparams(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static const ::stream::ScanParamCfg& borderparams(const ScannerCrtlCfgData* msg);
+  static void set_has_borderparams(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static const ::stream::ScanParamCfg& supportparams(const ScannerCrtlCfgData* msg);
+  static void set_has_supportparams(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static const ::stream::CorrectParamCfg& correctparamcfg(const ScannerCrtlCfgData* msg);
+  static void set_has_correctparamcfg(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static const ::stream::ScanTestCfg& scantestcfg(const ScannerCrtlCfgData* msg);
+  static void set_has_scantestcfg(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
+  static const ::stream::SkyWritingCfg& skywritingcfg(const ScannerCrtlCfgData* msg);
+  static void set_has_skywritingcfg(HasBits* has_bits) {
+    (*has_bits)[0] |= 64u;
+  }
+};
+
+const ::stream::ScanParamCfg& ScannerCrtlCfgData::_Internal::scanparamcfg(const ScannerCrtlCfgData* msg) {
+  return *msg->_impl_.scanparamcfg_;
+}
+const ::stream::ScanParamCfg& ScannerCrtlCfgData::_Internal::hatchingparams(const ScannerCrtlCfgData* msg) {
+  return *msg->_impl_.hatchingparams_;
+}
+const ::stream::ScanParamCfg& ScannerCrtlCfgData::_Internal::borderparams(const ScannerCrtlCfgData* msg) {
+  return *msg->_impl_.borderparams_;
+}
+const ::stream::ScanParamCfg& ScannerCrtlCfgData::_Internal::supportparams(const ScannerCrtlCfgData* msg) {
+  return *msg->_impl_.supportparams_;
+}
+const ::stream::CorrectParamCfg& ScannerCrtlCfgData::_Internal::correctparamcfg(const ScannerCrtlCfgData* msg) {
+  return *msg->_impl_.correctparamcfg_;
+}
+const ::stream::ScanTestCfg& ScannerCrtlCfgData::_Internal::scantestcfg(const ScannerCrtlCfgData* msg) {
+  return *msg->_impl_.scantestcfg_;
+}
+const ::stream::SkyWritingCfg& ScannerCrtlCfgData::_Internal::skywritingcfg(const ScannerCrtlCfgData* msg) {
+  return *msg->_impl_.skywritingcfg_;
+}
+ScannerCrtlCfgData::ScannerCrtlCfgData(::google::protobuf::Arena* arena)
+    : ::google::protobuf::Message(arena) {
+  SharedCtor(arena);
+  // @@protoc_insertion_point(arena_constructor:stream.ScannerCrtlCfgData)
+}
+ScannerCrtlCfgData::ScannerCrtlCfgData(const ScannerCrtlCfgData& from) : ::google::protobuf::Message() {
+  ScannerCrtlCfgData* const _this = this;
+  (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_},
+      /*decltype(_impl_._cached_size_)*/ {},
+      decltype(_impl_.fixpointdata_){from._impl_.fixpointdata_},
+      decltype(_impl_.powercompensate_){from._impl_.powercompensate_},
+      decltype(_impl_.tpowercompensate_){from._impl_.tpowercompensate_},
+      decltype(_impl_.cardname_){},
+      decltype(_impl_.cardip_){},
+      decltype(_impl_.scanparamcfg_){nullptr},
+      decltype(_impl_.hatchingparams_){nullptr},
+      decltype(_impl_.borderparams_){nullptr},
+      decltype(_impl_.supportparams_){nullptr},
+      decltype(_impl_.correctparamcfg_){nullptr},
+      decltype(_impl_.scantestcfg_){nullptr},
+      decltype(_impl_.skywritingcfg_){nullptr},
+      decltype(_impl_.seqno_){},
+      decltype(_impl_.controlno_){},
+      decltype(_impl_.serialno_){},
+      decltype(_impl_.controltype_){},
+      decltype(_impl_.isenable_){},
+      decltype(_impl_.hadassign_){},
+      decltype(_impl_.hadmatch_){},
+  };
+  _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
+      from._internal_metadata_);
+  _impl_.cardname_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        _impl_.cardname_.Set("", GetArenaForAllocation());
+  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (!from._internal_cardname().empty()) {
+    _this->_impl_.cardname_.Set(from._internal_cardname(), _this->GetArenaForAllocation());
+  }
+  _impl_.cardip_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        _impl_.cardip_.Set("", GetArenaForAllocation());
+  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (!from._internal_cardip().empty()) {
+    _this->_impl_.cardip_.Set(from._internal_cardip(), _this->GetArenaForAllocation());
+  }
+  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
+    _this->_impl_.scanparamcfg_ = new ::stream::ScanParamCfg(*from._impl_.scanparamcfg_);
+  }
+  if ((from._impl_._has_bits_[0] & 0x00000002u) != 0) {
+    _this->_impl_.hatchingparams_ = new ::stream::ScanParamCfg(*from._impl_.hatchingparams_);
+  }
+  if ((from._impl_._has_bits_[0] & 0x00000004u) != 0) {
+    _this->_impl_.borderparams_ = new ::stream::ScanParamCfg(*from._impl_.borderparams_);
+  }
+  if ((from._impl_._has_bits_[0] & 0x00000008u) != 0) {
+    _this->_impl_.supportparams_ = new ::stream::ScanParamCfg(*from._impl_.supportparams_);
+  }
+  if ((from._impl_._has_bits_[0] & 0x00000010u) != 0) {
+    _this->_impl_.correctparamcfg_ = new ::stream::CorrectParamCfg(*from._impl_.correctparamcfg_);
+  }
+  if ((from._impl_._has_bits_[0] & 0x00000020u) != 0) {
+    _this->_impl_.scantestcfg_ = new ::stream::ScanTestCfg(*from._impl_.scantestcfg_);
+  }
+  if ((from._impl_._has_bits_[0] & 0x00000040u) != 0) {
+    _this->_impl_.skywritingcfg_ = new ::stream::SkyWritingCfg(*from._impl_.skywritingcfg_);
+  }
+  ::memcpy(&_impl_.seqno_, &from._impl_.seqno_,
+    static_cast<::size_t>(reinterpret_cast<char*>(&_impl_.hadmatch_) -
+    reinterpret_cast<char*>(&_impl_.seqno_)) + sizeof(_impl_.hadmatch_));
+
+  // @@protoc_insertion_point(copy_constructor:stream.ScannerCrtlCfgData)
+}
+inline void ScannerCrtlCfgData::SharedCtor(::_pb::Arena* arena) {
+  (void)arena;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){},
+      /*decltype(_impl_._cached_size_)*/ {},
+      decltype(_impl_.fixpointdata_){arena},
+      decltype(_impl_.powercompensate_){arena},
+      decltype(_impl_.tpowercompensate_){arena},
+      decltype(_impl_.cardname_){},
+      decltype(_impl_.cardip_){},
+      decltype(_impl_.scanparamcfg_){nullptr},
+      decltype(_impl_.hatchingparams_){nullptr},
+      decltype(_impl_.borderparams_){nullptr},
+      decltype(_impl_.supportparams_){nullptr},
+      decltype(_impl_.correctparamcfg_){nullptr},
+      decltype(_impl_.scantestcfg_){nullptr},
+      decltype(_impl_.skywritingcfg_){nullptr},
+      decltype(_impl_.seqno_){0},
+      decltype(_impl_.controlno_){0},
+      decltype(_impl_.serialno_){0},
+      decltype(_impl_.controltype_){0},
+      decltype(_impl_.isenable_){false},
+      decltype(_impl_.hadassign_){false},
+      decltype(_impl_.hadmatch_){false},
+  };
+  _impl_.cardname_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        _impl_.cardname_.Set("", GetArenaForAllocation());
+  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.cardip_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        _impl_.cardip_.Set("", GetArenaForAllocation());
+  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+ScannerCrtlCfgData::~ScannerCrtlCfgData() {
+  // @@protoc_insertion_point(destructor:stream.ScannerCrtlCfgData)
+  _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
+  SharedDtor();
+}
+inline void ScannerCrtlCfgData::SharedDtor() {
+  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.fixpointdata_.~RepeatedPtrField();
+  _impl_.powercompensate_.~RepeatedPtrField();
+  _impl_.tpowercompensate_.~RepeatedPtrField();
+  _impl_.cardname_.Destroy();
+  _impl_.cardip_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.scanparamcfg_;
+  if (this != internal_default_instance()) delete _impl_.hatchingparams_;
+  if (this != internal_default_instance()) delete _impl_.borderparams_;
+  if (this != internal_default_instance()) delete _impl_.supportparams_;
+  if (this != internal_default_instance()) delete _impl_.correctparamcfg_;
+  if (this != internal_default_instance()) delete _impl_.scantestcfg_;
+  if (this != internal_default_instance()) delete _impl_.skywritingcfg_;
+}
+void ScannerCrtlCfgData::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+PROTOBUF_NOINLINE void ScannerCrtlCfgData::Clear() {
+// @@protoc_insertion_point(message_clear_start:stream.ScannerCrtlCfgData)
+  ::uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _internal_mutable_fixpointdata()->Clear();
+  _internal_mutable_powercompensate()->Clear();
+  _internal_mutable_tpowercompensate()->Clear();
+  _impl_.cardname_.ClearToEmpty();
+  _impl_.cardip_.ClearToEmpty();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000007fu) {
+    if (cached_has_bits & 0x00000001u) {
+      ABSL_DCHECK(_impl_.scanparamcfg_ != nullptr);
+      _impl_.scanparamcfg_->Clear();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      ABSL_DCHECK(_impl_.hatchingparams_ != nullptr);
+      _impl_.hatchingparams_->Clear();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      ABSL_DCHECK(_impl_.borderparams_ != nullptr);
+      _impl_.borderparams_->Clear();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      ABSL_DCHECK(_impl_.supportparams_ != nullptr);
+      _impl_.supportparams_->Clear();
+    }
+    if (cached_has_bits & 0x00000010u) {
+      ABSL_DCHECK(_impl_.correctparamcfg_ != nullptr);
+      _impl_.correctparamcfg_->Clear();
+    }
+    if (cached_has_bits & 0x00000020u) {
+      ABSL_DCHECK(_impl_.scantestcfg_ != nullptr);
+      _impl_.scantestcfg_->Clear();
+    }
+    if (cached_has_bits & 0x00000040u) {
+      ABSL_DCHECK(_impl_.skywritingcfg_ != nullptr);
+      _impl_.skywritingcfg_->Clear();
+    }
+  }
+  ::memset(&_impl_.seqno_, 0, static_cast<::size_t>(
+      reinterpret_cast<char*>(&_impl_.hadmatch_) -
+      reinterpret_cast<char*>(&_impl_.seqno_)) + sizeof(_impl_.hadmatch_));
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
+}
+
+const char* ScannerCrtlCfgData::_InternalParse(
+    const char* ptr, ::_pbi::ParseContext* ctx) {
+  ptr = ::_pbi::TcParser::ParseLoop(this, ptr, ctx, &_table_.header);
+  return ptr;
+}
+
+
+PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
+const ::_pbi::TcParseTable<5, 19, 10, 0, 2> ScannerCrtlCfgData::_table_ = {
+  {
+    PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_._has_bits_),
+    0, // no _extensions_
+    19, 248,  // max_field_number, fast_idx_mask
+    offsetof(decltype(_table_), field_lookup_table),
+    4294443008,  // skipmap
+    offsetof(decltype(_table_), field_entries),
+    19,  // num_field_entries
+    10,  // num_aux_entries
+    offsetof(decltype(_table_), aux_entries),
+    &_ScannerCrtlCfgData_default_instance_._instance,
+    ::_pbi::TcParser::GenericFallback,  // fallback
+  }, {{
+    {::_pbi::TcParser::MiniParse, {}},
+    // int32 seqNo = 1;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScannerCrtlCfgData, _impl_.seqno_), 63>(),
+     {8, 63, 0, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.seqno_)}},
+    // repeated .stream.FixPointData fixPointData = 2;
+    {::_pbi::TcParser::FastMtR1,
+     {18, 63, 0, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.fixpointdata_)}},
+    // .stream.ScanParamCfg scanParamCfg = 3;
+    {::_pbi::TcParser::FastMtS1,
+     {26, 0, 1, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.scanparamcfg_)}},
+    // .stream.ScanParamCfg hatchingParams = 4;
+    {::_pbi::TcParser::FastMtS1,
+     {34, 1, 2, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.hatchingparams_)}},
+    // .stream.ScanParamCfg borderParams = 5;
+    {::_pbi::TcParser::FastMtS1,
+     {42, 2, 3, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.borderparams_)}},
+    // .stream.ScanParamCfg supportParams = 6;
+    {::_pbi::TcParser::FastMtS1,
+     {50, 3, 4, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.supportparams_)}},
+    // .stream.CorrectParamCfg correctParamCfg = 7;
+    {::_pbi::TcParser::FastMtS1,
+     {58, 4, 5, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.correctparamcfg_)}},
+    // .stream.ScanTestCfg scanTestCfg = 8;
+    {::_pbi::TcParser::FastMtS1,
+     {66, 5, 6, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.scantestcfg_)}},
+    // .stream.SkyWritingCfg skyWritingCfg = 9;
+    {::_pbi::TcParser::FastMtS1,
+     {74, 6, 7, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.skywritingcfg_)}},
+    // repeated .stream.PowerCompensate powerCompensate = 10;
+    {::_pbi::TcParser::FastMtR1,
+     {82, 63, 8, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.powercompensate_)}},
+    // repeated .stream.TimePowerCompensate tPowerCompensate = 11;
+    {::_pbi::TcParser::FastMtR1,
+     {90, 63, 9, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.tpowercompensate_)}},
+    // int32 controlNo = 12;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScannerCrtlCfgData, _impl_.controlno_), 63>(),
+     {96, 63, 0, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.controlno_)}},
+    // int32 serialNo = 13;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScannerCrtlCfgData, _impl_.serialno_), 63>(),
+     {104, 63, 0, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.serialno_)}},
+    // int32 controlType = 14;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScannerCrtlCfgData, _impl_.controltype_), 63>(),
+     {112, 63, 0, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.controltype_)}},
+    // bytes cardName = 15;
+    {::_pbi::TcParser::FastBS1,
+     {122, 63, 0, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.cardname_)}},
+    // bytes cardIP = 16;
+    {::_pbi::TcParser::FastBS2,
+     {386, 63, 0, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.cardip_)}},
+    // bool isEnable = 17;
+    {::_pbi::TcParser::FastV8S2,
+     {392, 63, 0, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.isenable_)}},
+    // bool hadAssign = 18;
+    {::_pbi::TcParser::FastV8S2,
+     {400, 63, 0, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.hadassign_)}},
+    // bool hadMatch = 19;
+    {::_pbi::TcParser::FastV8S2,
+     {408, 63, 0, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.hadmatch_)}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+  }}, {{
+    65535, 65535
+  }}, {{
+    // int32 seqNo = 1;
+    {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.seqno_), -1, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt32)},
+    // repeated .stream.FixPointData fixPointData = 2;
+    {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.fixpointdata_), -1, 0,
+    (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)},
+    // .stream.ScanParamCfg scanParamCfg = 3;
+    {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.scanparamcfg_), _Internal::kHasBitsOffset + 0, 1,
+    (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
+    // .stream.ScanParamCfg hatchingParams = 4;
+    {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.hatchingparams_), _Internal::kHasBitsOffset + 1, 2,
+    (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
+    // .stream.ScanParamCfg borderParams = 5;
+    {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.borderparams_), _Internal::kHasBitsOffset + 2, 3,
+    (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
+    // .stream.ScanParamCfg supportParams = 6;
+    {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.supportparams_), _Internal::kHasBitsOffset + 3, 4,
+    (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
+    // .stream.CorrectParamCfg correctParamCfg = 7;
+    {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.correctparamcfg_), _Internal::kHasBitsOffset + 4, 5,
+    (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
+    // .stream.ScanTestCfg scanTestCfg = 8;
+    {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.scantestcfg_), _Internal::kHasBitsOffset + 5, 6,
+    (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
+    // .stream.SkyWritingCfg skyWritingCfg = 9;
+    {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.skywritingcfg_), _Internal::kHasBitsOffset + 6, 7,
+    (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
+    // repeated .stream.PowerCompensate powerCompensate = 10;
+    {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.powercompensate_), -1, 8,
+    (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)},
+    // repeated .stream.TimePowerCompensate tPowerCompensate = 11;
+    {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.tpowercompensate_), -1, 9,
+    (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)},
+    // int32 controlNo = 12;
+    {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.controlno_), -1, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt32)},
+    // int32 serialNo = 13;
+    {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.serialno_), -1, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt32)},
+    // int32 controlType = 14;
+    {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.controltype_), -1, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt32)},
+    // bytes cardName = 15;
+    {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.cardname_), -1, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)},
+    // bytes cardIP = 16;
+    {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.cardip_), -1, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)},
+    // bool isEnable = 17;
+    {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.isenable_), -1, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kBool)},
+    // bool hadAssign = 18;
+    {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.hadassign_), -1, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kBool)},
+    // bool hadMatch = 19;
+    {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.hadmatch_), -1, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kBool)},
+  }}, {{
+    {::_pbi::TcParser::GetTable<::stream::FixPointData>()},
+    {::_pbi::TcParser::GetTable<::stream::ScanParamCfg>()},
+    {::_pbi::TcParser::GetTable<::stream::ScanParamCfg>()},
+    {::_pbi::TcParser::GetTable<::stream::ScanParamCfg>()},
+    {::_pbi::TcParser::GetTable<::stream::ScanParamCfg>()},
+    {::_pbi::TcParser::GetTable<::stream::CorrectParamCfg>()},
+    {::_pbi::TcParser::GetTable<::stream::ScanTestCfg>()},
+    {::_pbi::TcParser::GetTable<::stream::SkyWritingCfg>()},
+    {::_pbi::TcParser::GetTable<::stream::PowerCompensate>()},
+    {::_pbi::TcParser::GetTable<::stream::TimePowerCompensate>()},
+  }}, {{
+  }},
+};
+
+::uint8_t* ScannerCrtlCfgData::_InternalSerialize(
+    ::uint8_t* target,
+    ::google::protobuf::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:stream.ScannerCrtlCfgData)
+  ::uint32_t cached_has_bits = 0;
+  (void)cached_has_bits;
+
+  // int32 seqNo = 1;
+  if (this->_internal_seqno() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt32ToArrayWithField<1>(
+            stream, this->_internal_seqno(), target);
+  }
+
+  // repeated .stream.FixPointData fixPointData = 2;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_fixpointdata_size()); i < n; i++) {
+    const auto& repfield = this->_internal_fixpointdata().Get(i);
+    target = ::google::protobuf::internal::WireFormatLite::
+        InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // .stream.ScanParamCfg scanParamCfg = 3;
+  if (cached_has_bits & 0x00000001u) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      InternalWriteMessage(3, _Internal::scanparamcfg(this),
+        _Internal::scanparamcfg(this).GetCachedSize(), target, stream);
+  }
+
+  // .stream.ScanParamCfg hatchingParams = 4;
+  if (cached_has_bits & 0x00000002u) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      InternalWriteMessage(4, _Internal::hatchingparams(this),
+        _Internal::hatchingparams(this).GetCachedSize(), target, stream);
+  }
+
+  // .stream.ScanParamCfg borderParams = 5;
+  if (cached_has_bits & 0x00000004u) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      InternalWriteMessage(5, _Internal::borderparams(this),
+        _Internal::borderparams(this).GetCachedSize(), target, stream);
+  }
+
+  // .stream.ScanParamCfg supportParams = 6;
+  if (cached_has_bits & 0x00000008u) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      InternalWriteMessage(6, _Internal::supportparams(this),
+        _Internal::supportparams(this).GetCachedSize(), target, stream);
+  }
+
+  // .stream.CorrectParamCfg correctParamCfg = 7;
+  if (cached_has_bits & 0x00000010u) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      InternalWriteMessage(7, _Internal::correctparamcfg(this),
+        _Internal::correctparamcfg(this).GetCachedSize(), target, stream);
+  }
+
+  // .stream.ScanTestCfg scanTestCfg = 8;
+  if (cached_has_bits & 0x00000020u) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      InternalWriteMessage(8, _Internal::scantestcfg(this),
+        _Internal::scantestcfg(this).GetCachedSize(), target, stream);
+  }
+
+  // .stream.SkyWritingCfg skyWritingCfg = 9;
+  if (cached_has_bits & 0x00000040u) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      InternalWriteMessage(9, _Internal::skywritingcfg(this),
+        _Internal::skywritingcfg(this).GetCachedSize(), target, stream);
+  }
+
+  // repeated .stream.PowerCompensate powerCompensate = 10;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_powercompensate_size()); i < n; i++) {
+    const auto& repfield = this->_internal_powercompensate().Get(i);
+    target = ::google::protobuf::internal::WireFormatLite::
+        InternalWriteMessage(10, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  // repeated .stream.TimePowerCompensate tPowerCompensate = 11;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_tpowercompensate_size()); i < n; i++) {
+    const auto& repfield = this->_internal_tpowercompensate().Get(i);
+    target = ::google::protobuf::internal::WireFormatLite::
+        InternalWriteMessage(11, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  // int32 controlNo = 12;
+  if (this->_internal_controlno() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt32ToArrayWithField<12>(
+            stream, this->_internal_controlno(), target);
+  }
+
+  // int32 serialNo = 13;
+  if (this->_internal_serialno() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt32ToArrayWithField<13>(
+            stream, this->_internal_serialno(), target);
+  }
+
+  // int32 controlType = 14;
+  if (this->_internal_controltype() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt32ToArrayWithField<14>(
+            stream, this->_internal_controltype(), target);
+  }
+
+  // bytes cardName = 15;
+  if (!this->_internal_cardname().empty()) {
+    const std::string& _s = this->_internal_cardname();
+    target = stream->WriteBytesMaybeAliased(15, _s, target);
+  }
+
+  // bytes cardIP = 16;
+  if (!this->_internal_cardip().empty()) {
+    const std::string& _s = this->_internal_cardip();
+    target = stream->WriteBytesMaybeAliased(16, _s, target);
+  }
+
+  // bool isEnable = 17;
+  if (this->_internal_isenable() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(
+        17, this->_internal_isenable(), target);
+  }
+
+  // bool hadAssign = 18;
+  if (this->_internal_hadassign() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(
+        18, this->_internal_hadassign(), target);
+  }
+
+  // bool hadMatch = 19;
+  if (this->_internal_hadmatch() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(
+        19, this->_internal_hadmatch(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target =
+        ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
+            _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:stream.ScannerCrtlCfgData)
+  return target;
+}
+
+::size_t ScannerCrtlCfgData::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:stream.ScannerCrtlCfgData)
+  ::size_t total_size = 0;
+
+  ::uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .stream.FixPointData fixPointData = 2;
+  total_size += 1UL * this->_internal_fixpointdata_size();
+  for (const auto& msg : this->_internal_fixpointdata()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSize(msg);
+  }
+  // repeated .stream.PowerCompensate powerCompensate = 10;
+  total_size += 1UL * this->_internal_powercompensate_size();
+  for (const auto& msg : this->_internal_powercompensate()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSize(msg);
+  }
+  // repeated .stream.TimePowerCompensate tPowerCompensate = 11;
+  total_size += 1UL * this->_internal_tpowercompensate_size();
+  for (const auto& msg : this->_internal_tpowercompensate()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSize(msg);
+  }
+  // bytes cardName = 15;
+  if (!this->_internal_cardname().empty()) {
+    total_size += 1 + ::google::protobuf::internal::WireFormatLite::BytesSize(
+                                    this->_internal_cardname());
+  }
+
+  // bytes cardIP = 16;
+  if (!this->_internal_cardip().empty()) {
+    total_size += 2 + ::google::protobuf::internal::WireFormatLite::BytesSize(
+                                    this->_internal_cardip());
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000007fu) {
+    // .stream.ScanParamCfg scanParamCfg = 3;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSize(
+          *_impl_.scanparamcfg_);
+    }
+
+    // .stream.ScanParamCfg hatchingParams = 4;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSize(
+          *_impl_.hatchingparams_);
+    }
+
+    // .stream.ScanParamCfg borderParams = 5;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSize(
+          *_impl_.borderparams_);
+    }
+
+    // .stream.ScanParamCfg supportParams = 6;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSize(
+          *_impl_.supportparams_);
+    }
+
+    // .stream.CorrectParamCfg correctParamCfg = 7;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSize(
+          *_impl_.correctparamcfg_);
+    }
+
+    // .stream.ScanTestCfg scanTestCfg = 8;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSize(
+          *_impl_.scantestcfg_);
+    }
+
+    // .stream.SkyWritingCfg skyWritingCfg = 9;
+    if (cached_has_bits & 0x00000040u) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSize(
+          *_impl_.skywritingcfg_);
+    }
+
+  }
+  // int32 seqNo = 1;
+  if (this->_internal_seqno() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
+        this->_internal_seqno());
+  }
+
+  // int32 controlNo = 12;
+  if (this->_internal_controlno() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
+        this->_internal_controlno());
+  }
+
+  // int32 serialNo = 13;
+  if (this->_internal_serialno() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
+        this->_internal_serialno());
+  }
+
+  // int32 controlType = 14;
+  if (this->_internal_controltype() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
+        this->_internal_controltype());
+  }
+
+  // bool isEnable = 17;
+  if (this->_internal_isenable() != 0) {
+    total_size += 3;
+  }
+
+  // bool hadAssign = 18;
+  if (this->_internal_hadassign() != 0) {
+    total_size += 3;
+  }
+
+  // bool hadMatch = 19;
+  if (this->_internal_hadmatch() != 0) {
+    total_size += 3;
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::google::protobuf::Message::ClassData ScannerCrtlCfgData::_class_data_ = {
+    ::google::protobuf::Message::CopyWithSourceCheck,
+    ScannerCrtlCfgData::MergeImpl
+};
+const ::google::protobuf::Message::ClassData*ScannerCrtlCfgData::GetClassData() const { return &_class_data_; }
+
+
+void ScannerCrtlCfgData::MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg) {
+  auto* const _this = static_cast<ScannerCrtlCfgData*>(&to_msg);
+  auto& from = static_cast<const ScannerCrtlCfgData&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:stream.ScannerCrtlCfgData)
+  ABSL_DCHECK_NE(&from, _this);
+  ::uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_internal_mutable_fixpointdata()->MergeFrom(from._internal_fixpointdata());
+  _this->_internal_mutable_powercompensate()->MergeFrom(from._internal_powercompensate());
+  _this->_internal_mutable_tpowercompensate()->MergeFrom(from._internal_tpowercompensate());
+  if (!from._internal_cardname().empty()) {
+    _this->_internal_set_cardname(from._internal_cardname());
+  }
+  if (!from._internal_cardip().empty()) {
+    _this->_internal_set_cardip(from._internal_cardip());
+  }
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000007fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_mutable_scanparamcfg()->::stream::ScanParamCfg::MergeFrom(
+          from._internal_scanparamcfg());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_mutable_hatchingparams()->::stream::ScanParamCfg::MergeFrom(
+          from._internal_hatchingparams());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_mutable_borderparams()->::stream::ScanParamCfg::MergeFrom(
+          from._internal_borderparams());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_mutable_supportparams()->::stream::ScanParamCfg::MergeFrom(
+          from._internal_supportparams());
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_internal_mutable_correctparamcfg()->::stream::CorrectParamCfg::MergeFrom(
+          from._internal_correctparamcfg());
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_internal_mutable_scantestcfg()->::stream::ScanTestCfg::MergeFrom(
+          from._internal_scantestcfg());
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _this->_internal_mutable_skywritingcfg()->::stream::SkyWritingCfg::MergeFrom(
+          from._internal_skywritingcfg());
+    }
+  }
+  if (from._internal_seqno() != 0) {
+    _this->_internal_set_seqno(from._internal_seqno());
+  }
+  if (from._internal_controlno() != 0) {
+    _this->_internal_set_controlno(from._internal_controlno());
+  }
+  if (from._internal_serialno() != 0) {
+    _this->_internal_set_serialno(from._internal_serialno());
+  }
+  if (from._internal_controltype() != 0) {
+    _this->_internal_set_controltype(from._internal_controltype());
+  }
+  if (from._internal_isenable() != 0) {
+    _this->_internal_set_isenable(from._internal_isenable());
+  }
+  if (from._internal_hadassign() != 0) {
+    _this->_internal_set_hadassign(from._internal_hadassign());
+  }
+  if (from._internal_hadmatch() != 0) {
+    _this->_internal_set_hadmatch(from._internal_hadmatch());
+  }
+  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ScannerCrtlCfgData::CopyFrom(const ScannerCrtlCfgData& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:stream.ScannerCrtlCfgData)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+PROTOBUF_NOINLINE bool ScannerCrtlCfgData::IsInitialized() const {
+  return true;
+}
+
+void ScannerCrtlCfgData::InternalSwap(ScannerCrtlCfgData* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.fixpointdata_.InternalSwap(&other->_impl_.fixpointdata_);
+  _impl_.powercompensate_.InternalSwap(&other->_impl_.powercompensate_);
+  _impl_.tpowercompensate_.InternalSwap(&other->_impl_.tpowercompensate_);
+  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.cardname_, lhs_arena,
+                                       &other->_impl_.cardname_, rhs_arena);
+  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.cardip_, lhs_arena,
+                                       &other->_impl_.cardip_, rhs_arena);
+  ::google::protobuf::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.hadmatch_)
+      + sizeof(ScannerCrtlCfgData::_impl_.hadmatch_)
+      - PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.scanparamcfg_)>(
+          reinterpret_cast<char*>(&_impl_.scanparamcfg_),
+          reinterpret_cast<char*>(&other->_impl_.scanparamcfg_));
+}
+
+::google::protobuf::Metadata ScannerCrtlCfgData::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_stream_2eproto_getter, &descriptor_table_stream_2eproto_once,
+      file_level_metadata_stream_2eproto[13]);
+}
+// ===================================================================
+
+class FixPointData::_Internal {
+ public:
+};
+
+FixPointData::FixPointData(::google::protobuf::Arena* arena)
+    : ::google::protobuf::Message(arena) {
+  SharedCtor(arena);
+  // @@protoc_insertion_point(arena_constructor:stream.FixPointData)
+}
+FixPointData::FixPointData(const FixPointData& from)
+    : ::google::protobuf::Message(), _impl_(from._impl_) {
+  _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
+      from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:stream.FixPointData)
+}
+inline void FixPointData::SharedCtor(::_pb::Arena* arena) {
+  (void)arena;
+  new (&_impl_) Impl_{
+      decltype(_impl_.id_){0},
+      decltype(_impl_.cno_){0},
+      decltype(_impl_.pointx_){0},
+      decltype(_impl_.pointy_){0},
+      decltype(_impl_.duration_){0u},
+      /*decltype(_impl_._cached_size_)*/ {},
+  };
+}
+FixPointData::~FixPointData() {
+  // @@protoc_insertion_point(destructor:stream.FixPointData)
+  _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
+  SharedDtor();
+}
+inline void FixPointData::SharedDtor() {
+  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
+}
+void FixPointData::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+PROTOBUF_NOINLINE void FixPointData::Clear() {
+// @@protoc_insertion_point(message_clear_start:stream.FixPointData)
+  ::uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  ::memset(&_impl_.id_, 0, static_cast<::size_t>(
+      reinterpret_cast<char*>(&_impl_.duration_) -
+      reinterpret_cast<char*>(&_impl_.id_)) + sizeof(_impl_.duration_));
+  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
+}
+
+const char* FixPointData::_InternalParse(
+    const char* ptr, ::_pbi::ParseContext* ctx) {
+  ptr = ::_pbi::TcParser::ParseLoop(this, ptr, ctx, &_table_.header);
+  return ptr;
+}
+
+
+PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
+const ::_pbi::TcParseTable<3, 5, 0, 0, 2> FixPointData::_table_ = {
+  {
+    0,  // no _has_bits_
+    0, // no _extensions_
+    5, 56,  // max_field_number, fast_idx_mask
+    offsetof(decltype(_table_), field_lookup_table),
+    4294967264,  // skipmap
+    offsetof(decltype(_table_), field_entries),
+    5,  // num_field_entries
+    0,  // num_aux_entries
+    offsetof(decltype(_table_), field_names),  // no aux_entries
+    &_FixPointData_default_instance_._instance,
+    ::_pbi::TcParser::GenericFallback,  // fallback
+  }, {{
+    {::_pbi::TcParser::MiniParse, {}},
+    // int32 id = 1;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(FixPointData, _impl_.id_), 63>(),
+     {8, 63, 0, PROTOBUF_FIELD_OFFSET(FixPointData, _impl_.id_)}},
+    // int32 cno = 2;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(FixPointData, _impl_.cno_), 63>(),
+     {16, 63, 0, PROTOBUF_FIELD_OFFSET(FixPointData, _impl_.cno_)}},
+    // float pointX = 3;
+    {::_pbi::TcParser::FastF32S1,
+     {29, 63, 0, PROTOBUF_FIELD_OFFSET(FixPointData, _impl_.pointx_)}},
+    // float pointY = 4;
+    {::_pbi::TcParser::FastF32S1,
+     {37, 63, 0, PROTOBUF_FIELD_OFFSET(FixPointData, _impl_.pointy_)}},
+    // uint32 duration = 5;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(FixPointData, _impl_.duration_), 63>(),
+     {40, 63, 0, PROTOBUF_FIELD_OFFSET(FixPointData, _impl_.duration_)}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+  }}, {{
+    65535, 65535
+  }}, {{
+    // int32 id = 1;
+    {PROTOBUF_FIELD_OFFSET(FixPointData, _impl_.id_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt32)},
+    // int32 cno = 2;
+    {PROTOBUF_FIELD_OFFSET(FixPointData, _impl_.cno_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt32)},
+    // float pointX = 3;
+    {PROTOBUF_FIELD_OFFSET(FixPointData, _impl_.pointx_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kFloat)},
+    // float pointY = 4;
+    {PROTOBUF_FIELD_OFFSET(FixPointData, _impl_.pointy_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kFloat)},
+    // uint32 duration = 5;
+    {PROTOBUF_FIELD_OFFSET(FixPointData, _impl_.duration_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kUInt32)},
+  }},
+  // no aux_entries
+  {{
+  }},
+};
+
+::uint8_t* FixPointData::_InternalSerialize(
+    ::uint8_t* target,
+    ::google::protobuf::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:stream.FixPointData)
+  ::uint32_t cached_has_bits = 0;
+  (void)cached_has_bits;
+
+  // int32 id = 1;
+  if (this->_internal_id() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt32ToArrayWithField<1>(
+            stream, this->_internal_id(), target);
+  }
+
+  // int32 cno = 2;
+  if (this->_internal_cno() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt32ToArrayWithField<2>(
+            stream, this->_internal_cno(), target);
+  }
+
+  // float pointX = 3;
+  static_assert(sizeof(::uint32_t) == sizeof(float),
+                "Code assumes ::uint32_t and float are the same size.");
+  float tmp_pointx = this->_internal_pointx();
+  ::uint32_t raw_pointx;
+  memcpy(&raw_pointx, &tmp_pointx, sizeof(tmp_pointx));
+  if (raw_pointx != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteFloatToArray(
+        3, this->_internal_pointx(), target);
+  }
+
+  // float pointY = 4;
+  static_assert(sizeof(::uint32_t) == sizeof(float),
+                "Code assumes ::uint32_t and float are the same size.");
+  float tmp_pointy = this->_internal_pointy();
+  ::uint32_t raw_pointy;
+  memcpy(&raw_pointy, &tmp_pointy, sizeof(tmp_pointy));
+  if (raw_pointy != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteFloatToArray(
+        4, this->_internal_pointy(), target);
+  }
+
+  // uint32 duration = 5;
+  if (this->_internal_duration() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
+        5, this->_internal_duration(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target =
+        ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
+            _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:stream.FixPointData)
+  return target;
+}
+
+::size_t FixPointData::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:stream.FixPointData)
+  ::size_t total_size = 0;
+
+  ::uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // int32 id = 1;
+  if (this->_internal_id() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
+        this->_internal_id());
+  }
+
+  // int32 cno = 2;
+  if (this->_internal_cno() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
+        this->_internal_cno());
+  }
+
+  // float pointX = 3;
+  static_assert(sizeof(::uint32_t) == sizeof(float),
+                "Code assumes ::uint32_t and float are the same size.");
+  float tmp_pointx = this->_internal_pointx();
+  ::uint32_t raw_pointx;
+  memcpy(&raw_pointx, &tmp_pointx, sizeof(tmp_pointx));
+  if (raw_pointx != 0) {
+    total_size += 5;
+  }
+
+  // float pointY = 4;
+  static_assert(sizeof(::uint32_t) == sizeof(float),
+                "Code assumes ::uint32_t and float are the same size.");
+  float tmp_pointy = this->_internal_pointy();
+  ::uint32_t raw_pointy;
+  memcpy(&raw_pointy, &tmp_pointy, sizeof(tmp_pointy));
+  if (raw_pointy != 0) {
+    total_size += 5;
+  }
+
+  // uint32 duration = 5;
+  if (this->_internal_duration() != 0) {
+    total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
+        this->_internal_duration());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::google::protobuf::Message::ClassData FixPointData::_class_data_ = {
+    ::google::protobuf::Message::CopyWithSourceCheck,
+    FixPointData::MergeImpl
+};
+const ::google::protobuf::Message::ClassData*FixPointData::GetClassData() const { return &_class_data_; }
+
+
+void FixPointData::MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg) {
+  auto* const _this = static_cast<FixPointData*>(&to_msg);
+  auto& from = static_cast<const FixPointData&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:stream.FixPointData)
+  ABSL_DCHECK_NE(&from, _this);
+  ::uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_id() != 0) {
+    _this->_internal_set_id(from._internal_id());
+  }
+  if (from._internal_cno() != 0) {
+    _this->_internal_set_cno(from._internal_cno());
+  }
+  static_assert(sizeof(::uint32_t) == sizeof(float),
+                "Code assumes ::uint32_t and float are the same size.");
+  float tmp_pointx = from._internal_pointx();
+  ::uint32_t raw_pointx;
+  memcpy(&raw_pointx, &tmp_pointx, sizeof(tmp_pointx));
+  if (raw_pointx != 0) {
+    _this->_internal_set_pointx(from._internal_pointx());
+  }
+  static_assert(sizeof(::uint32_t) == sizeof(float),
+                "Code assumes ::uint32_t and float are the same size.");
+  float tmp_pointy = from._internal_pointy();
+  ::uint32_t raw_pointy;
+  memcpy(&raw_pointy, &tmp_pointy, sizeof(tmp_pointy));
+  if (raw_pointy != 0) {
+    _this->_internal_set_pointy(from._internal_pointy());
+  }
+  if (from._internal_duration() != 0) {
+    _this->_internal_set_duration(from._internal_duration());
+  }
+  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void FixPointData::CopyFrom(const FixPointData& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:stream.FixPointData)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+PROTOBUF_NOINLINE bool FixPointData::IsInitialized() const {
+  return true;
+}
+
+void FixPointData::InternalSwap(FixPointData* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::google::protobuf::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(FixPointData, _impl_.duration_)
+      + sizeof(FixPointData::_impl_.duration_)
+      - PROTOBUF_FIELD_OFFSET(FixPointData, _impl_.id_)>(
+          reinterpret_cast<char*>(&_impl_.id_),
+          reinterpret_cast<char*>(&other->_impl_.id_));
+}
+
+::google::protobuf::Metadata FixPointData::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_stream_2eproto_getter, &descriptor_table_stream_2eproto_once,
+      file_level_metadata_stream_2eproto[14]);
+}
+// ===================================================================
+
+class ScanParamCfg::_Internal {
+ public:
+};
+
+ScanParamCfg::ScanParamCfg(::google::protobuf::Arena* arena)
+    : ::google::protobuf::Message(arena) {
+  SharedCtor(arena);
+  // @@protoc_insertion_point(arena_constructor:stream.ScanParamCfg)
+}
+ScanParamCfg::ScanParamCfg(const ScanParamCfg& from)
+    : ::google::protobuf::Message(), _impl_(from._impl_) {
+  _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
+      from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:stream.ScanParamCfg)
+}
+inline void ScanParamCfg::SharedCtor(::_pb::Arena* arena) {
+  (void)arena;
+  new (&_impl_) Impl_{
+      decltype(_impl_.edgelevel_){0},
+      decltype(_impl_.edgelevelmin_){0},
+      decltype(_impl_.edgelevelmax_){0},
+      decltype(_impl_.jumpdelay_){0u},
+      decltype(_impl_.jumpdelaymin_){0u},
+      decltype(_impl_.jumpdelaymax_){0u},
+      decltype(_impl_.scandelay_){0u},
+      decltype(_impl_.scandelaymin_){0u},
+      decltype(_impl_.scandelaymax_){0u},
+      decltype(_impl_.polygondelay_){0u},
+      decltype(_impl_.polygondelaymin_){0u},
+      decltype(_impl_.polygondelaymax_){0u},
+      decltype(_impl_.laseroffdelay_){::int64_t{0}},
+      decltype(_impl_.laseroffdelaymin_){::int64_t{0}},
+      decltype(_impl_.laseroffdelaymax_){::int64_t{0}},
+      decltype(_impl_.laserondelay_){::int64_t{0}},
+      decltype(_impl_.laserondelaymin_){::int64_t{0}},
+      decltype(_impl_.laserondelaymax_){::int64_t{0}},
+      decltype(_impl_.minjumpdelay_){0u},
+      decltype(_impl_.minjumpdelaymin_){0u},
+      decltype(_impl_.minjumpdelaymax_){0u},
+      decltype(_impl_.jumplengthlimit_){0u},
+      decltype(_impl_.jumplengthlimitmin_){0u},
+      decltype(_impl_.jumplengthlimitmax_){0u},
+      decltype(_impl_.jumpspeed_){0},
+      decltype(_impl_.jumpspeedmin_){0},
+      decltype(_impl_.jumpspeedmax_){0},
+      decltype(_impl_.markspeed_){0},
+      decltype(_impl_.markspeedmin_){0},
+      decltype(_impl_.markspeedmax_){0},
+      /*decltype(_impl_._cached_size_)*/ {},
+  };
+}
+ScanParamCfg::~ScanParamCfg() {
+  // @@protoc_insertion_point(destructor:stream.ScanParamCfg)
+  _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
+  SharedDtor();
+}
+inline void ScanParamCfg::SharedDtor() {
+  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
+}
+void ScanParamCfg::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+PROTOBUF_NOINLINE void ScanParamCfg::Clear() {
+// @@protoc_insertion_point(message_clear_start:stream.ScanParamCfg)
+  ::uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  ::memset(&_impl_.edgelevel_, 0, static_cast<::size_t>(
+      reinterpret_cast<char*>(&_impl_.markspeedmax_) -
+      reinterpret_cast<char*>(&_impl_.edgelevel_)) + sizeof(_impl_.markspeedmax_));
+  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
+}
+
+const char* ScanParamCfg::_InternalParse(
+    const char* ptr, ::_pbi::ParseContext* ctx) {
+  ptr = ::_pbi::TcParser::ParseLoop(this, ptr, ctx, &_table_.header);
+  return ptr;
+}
+
+
+PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
+const ::_pbi::TcParseTable<5, 30, 0, 0, 2> ScanParamCfg::_table_ = {
+  {
+    0,  // no _has_bits_
+    0, // no _extensions_
+    30, 248,  // max_field_number, fast_idx_mask
+    offsetof(decltype(_table_), field_lookup_table),
+    3221225472,  // skipmap
+    offsetof(decltype(_table_), field_entries),
+    30,  // num_field_entries
+    0,  // num_aux_entries
+    offsetof(decltype(_table_), field_names),  // no aux_entries
+    &_ScanParamCfg_default_instance_._instance,
+    ::_pbi::TcParser::GenericFallback,  // fallback
+  }, {{
+    {::_pbi::TcParser::MiniParse, {}},
+    // int32 edgeLevel = 1;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanParamCfg, _impl_.edgelevel_), 63>(),
+     {8, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.edgelevel_)}},
+    // int32 edgeLevelMin = 2;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanParamCfg, _impl_.edgelevelmin_), 63>(),
+     {16, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.edgelevelmin_)}},
+    // int32 edgeLevelMax = 3;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanParamCfg, _impl_.edgelevelmax_), 63>(),
+     {24, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.edgelevelmax_)}},
+    // uint32 jumpDelay = 4;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanParamCfg, _impl_.jumpdelay_), 63>(),
+     {32, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumpdelay_)}},
+    // uint32 jumpDelayMin = 5;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanParamCfg, _impl_.jumpdelaymin_), 63>(),
+     {40, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumpdelaymin_)}},
+    // uint32 jumpDelayMax = 6;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanParamCfg, _impl_.jumpdelaymax_), 63>(),
+     {48, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumpdelaymax_)}},
+    // uint32 scanDelay = 7;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanParamCfg, _impl_.scandelay_), 63>(),
+     {56, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.scandelay_)}},
+    // uint32 scanDelayMin = 8;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanParamCfg, _impl_.scandelaymin_), 63>(),
+     {64, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.scandelaymin_)}},
+    // uint32 scanDelayMax = 9;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanParamCfg, _impl_.scandelaymax_), 63>(),
+     {72, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.scandelaymax_)}},
+    // uint32 polygonDelay = 10;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanParamCfg, _impl_.polygondelay_), 63>(),
+     {80, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.polygondelay_)}},
+    // uint32 polygonDelayMin = 11;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanParamCfg, _impl_.polygondelaymin_), 63>(),
+     {88, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.polygondelaymin_)}},
+    // uint32 polygonDelayMax = 12;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanParamCfg, _impl_.polygondelaymax_), 63>(),
+     {96, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.polygondelaymax_)}},
+    // int64 laseroffDelay = 13;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(ScanParamCfg, _impl_.laseroffdelay_), 63>(),
+     {104, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.laseroffdelay_)}},
+    // int64 laseroffDelayMin = 14;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(ScanParamCfg, _impl_.laseroffdelaymin_), 63>(),
+     {112, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.laseroffdelaymin_)}},
+    // int64 laseroffDelayMax = 15;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(ScanParamCfg, _impl_.laseroffdelaymax_), 63>(),
+     {120, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.laseroffdelaymax_)}},
+    // int64 laseronDelay = 16;
+    {::_pbi::TcParser::FastV64S2,
+     {384, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.laserondelay_)}},
+    // int64 laseronDelayMin = 17;
+    {::_pbi::TcParser::FastV64S2,
+     {392, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.laserondelaymin_)}},
+    // int64 laseronDelayMax = 18;
+    {::_pbi::TcParser::FastV64S2,
+     {400, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.laserondelaymax_)}},
+    // uint32 minJumpDelay = 19;
+    {::_pbi::TcParser::FastV32S2,
+     {408, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.minjumpdelay_)}},
+    // uint32 minJumpDelayMin = 20;
+    {::_pbi::TcParser::FastV32S2,
+     {416, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.minjumpdelaymin_)}},
+    // uint32 minJumpDelayMax = 21;
+    {::_pbi::TcParser::FastV32S2,
+     {424, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.minjumpdelaymax_)}},
+    // uint32 jumpLengthLimit = 22;
+    {::_pbi::TcParser::FastV32S2,
+     {432, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumplengthlimit_)}},
+    // uint32 jumpLengthLimitMin = 23;
+    {::_pbi::TcParser::FastV32S2,
+     {440, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumplengthlimitmin_)}},
+    // uint32 jumpLengthLimitMax = 24;
+    {::_pbi::TcParser::FastV32S2,
+     {448, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumplengthlimitmax_)}},
+    // double jumpSpeed = 25;
+    {::_pbi::TcParser::FastF64S2,
+     {457, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumpspeed_)}},
+    // double jumpSpeedMin = 26;
+    {::_pbi::TcParser::FastF64S2,
+     {465, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumpspeedmin_)}},
+    // double jumpSpeedMax = 27;
+    {::_pbi::TcParser::FastF64S2,
+     {473, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumpspeedmax_)}},
+    // double markSpeed = 28;
+    {::_pbi::TcParser::FastF64S2,
+     {481, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.markspeed_)}},
+    // double markSpeedMin = 29;
+    {::_pbi::TcParser::FastF64S2,
+     {489, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.markspeedmin_)}},
+    // double markSpeedMax = 30;
+    {::_pbi::TcParser::FastF64S2,
+     {497, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.markspeedmax_)}},
+    {::_pbi::TcParser::MiniParse, {}},
+  }}, {{
+    65535, 65535
+  }}, {{
+    // int32 edgeLevel = 1;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.edgelevel_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt32)},
+    // int32 edgeLevelMin = 2;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.edgelevelmin_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt32)},
+    // int32 edgeLevelMax = 3;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.edgelevelmax_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt32)},
+    // uint32 jumpDelay = 4;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumpdelay_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kUInt32)},
+    // uint32 jumpDelayMin = 5;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumpdelaymin_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kUInt32)},
+    // uint32 jumpDelayMax = 6;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumpdelaymax_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kUInt32)},
+    // uint32 scanDelay = 7;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.scandelay_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kUInt32)},
+    // uint32 scanDelayMin = 8;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.scandelaymin_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kUInt32)},
+    // uint32 scanDelayMax = 9;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.scandelaymax_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kUInt32)},
+    // uint32 polygonDelay = 10;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.polygondelay_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kUInt32)},
+    // uint32 polygonDelayMin = 11;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.polygondelaymin_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kUInt32)},
+    // uint32 polygonDelayMax = 12;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.polygondelaymax_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kUInt32)},
+    // int64 laseroffDelay = 13;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.laseroffdelay_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt64)},
+    // int64 laseroffDelayMin = 14;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.laseroffdelaymin_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt64)},
+    // int64 laseroffDelayMax = 15;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.laseroffdelaymax_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt64)},
+    // int64 laseronDelay = 16;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.laserondelay_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt64)},
+    // int64 laseronDelayMin = 17;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.laserondelaymin_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt64)},
+    // int64 laseronDelayMax = 18;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.laserondelaymax_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt64)},
+    // uint32 minJumpDelay = 19;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.minjumpdelay_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kUInt32)},
+    // uint32 minJumpDelayMin = 20;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.minjumpdelaymin_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kUInt32)},
+    // uint32 minJumpDelayMax = 21;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.minjumpdelaymax_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kUInt32)},
+    // uint32 jumpLengthLimit = 22;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumplengthlimit_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kUInt32)},
+    // uint32 jumpLengthLimitMin = 23;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumplengthlimitmin_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kUInt32)},
+    // uint32 jumpLengthLimitMax = 24;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumplengthlimitmax_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kUInt32)},
+    // double jumpSpeed = 25;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumpspeed_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double jumpSpeedMin = 26;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumpspeedmin_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double jumpSpeedMax = 27;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumpspeedmax_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double markSpeed = 28;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.markspeed_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double markSpeedMin = 29;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.markspeedmin_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double markSpeedMax = 30;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.markspeedmax_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+  }},
+  // no aux_entries
+  {{
+  }},
+};
+
+::uint8_t* ScanParamCfg::_InternalSerialize(
+    ::uint8_t* target,
+    ::google::protobuf::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:stream.ScanParamCfg)
+  ::uint32_t cached_has_bits = 0;
+  (void)cached_has_bits;
+
+  // int32 edgeLevel = 1;
+  if (this->_internal_edgelevel() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt32ToArrayWithField<1>(
+            stream, this->_internal_edgelevel(), target);
+  }
+
+  // int32 edgeLevelMin = 2;
+  if (this->_internal_edgelevelmin() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt32ToArrayWithField<2>(
+            stream, this->_internal_edgelevelmin(), target);
+  }
+
+  // int32 edgeLevelMax = 3;
+  if (this->_internal_edgelevelmax() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt32ToArrayWithField<3>(
+            stream, this->_internal_edgelevelmax(), target);
+  }
+
+  // uint32 jumpDelay = 4;
+  if (this->_internal_jumpdelay() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
+        4, this->_internal_jumpdelay(), target);
+  }
+
+  // uint32 jumpDelayMin = 5;
+  if (this->_internal_jumpdelaymin() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
+        5, this->_internal_jumpdelaymin(), target);
+  }
+
+  // uint32 jumpDelayMax = 6;
+  if (this->_internal_jumpdelaymax() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
+        6, this->_internal_jumpdelaymax(), target);
+  }
+
+  // uint32 scanDelay = 7;
+  if (this->_internal_scandelay() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
+        7, this->_internal_scandelay(), target);
+  }
+
+  // uint32 scanDelayMin = 8;
+  if (this->_internal_scandelaymin() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
+        8, this->_internal_scandelaymin(), target);
+  }
+
+  // uint32 scanDelayMax = 9;
+  if (this->_internal_scandelaymax() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
+        9, this->_internal_scandelaymax(), target);
+  }
+
+  // uint32 polygonDelay = 10;
+  if (this->_internal_polygondelay() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
+        10, this->_internal_polygondelay(), target);
+  }
+
+  // uint32 polygonDelayMin = 11;
+  if (this->_internal_polygondelaymin() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
+        11, this->_internal_polygondelaymin(), target);
+  }
+
+  // uint32 polygonDelayMax = 12;
+  if (this->_internal_polygondelaymax() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
+        12, this->_internal_polygondelaymax(), target);
+  }
+
+  // int64 laseroffDelay = 13;
+  if (this->_internal_laseroffdelay() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt64ToArrayWithField<13>(
+            stream, this->_internal_laseroffdelay(), target);
+  }
+
+  // int64 laseroffDelayMin = 14;
+  if (this->_internal_laseroffdelaymin() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt64ToArrayWithField<14>(
+            stream, this->_internal_laseroffdelaymin(), target);
+  }
+
+  // int64 laseroffDelayMax = 15;
+  if (this->_internal_laseroffdelaymax() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt64ToArrayWithField<15>(
+            stream, this->_internal_laseroffdelaymax(), target);
+  }
+
+  // int64 laseronDelay = 16;
+  if (this->_internal_laserondelay() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(
+        16, this->_internal_laserondelay(), target);
+  }
+
+  // int64 laseronDelayMin = 17;
+  if (this->_internal_laserondelaymin() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(
+        17, this->_internal_laserondelaymin(), target);
+  }
+
+  // int64 laseronDelayMax = 18;
+  if (this->_internal_laserondelaymax() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(
+        18, this->_internal_laserondelaymax(), target);
+  }
+
+  // uint32 minJumpDelay = 19;
+  if (this->_internal_minjumpdelay() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
+        19, this->_internal_minjumpdelay(), target);
+  }
+
+  // uint32 minJumpDelayMin = 20;
+  if (this->_internal_minjumpdelaymin() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
+        20, this->_internal_minjumpdelaymin(), target);
+  }
+
+  // uint32 minJumpDelayMax = 21;
+  if (this->_internal_minjumpdelaymax() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
+        21, this->_internal_minjumpdelaymax(), target);
+  }
+
+  // uint32 jumpLengthLimit = 22;
+  if (this->_internal_jumplengthlimit() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
+        22, this->_internal_jumplengthlimit(), target);
+  }
+
+  // uint32 jumpLengthLimitMin = 23;
+  if (this->_internal_jumplengthlimitmin() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
+        23, this->_internal_jumplengthlimitmin(), target);
+  }
+
+  // uint32 jumpLengthLimitMax = 24;
+  if (this->_internal_jumplengthlimitmax() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
+        24, this->_internal_jumplengthlimitmax(), target);
+  }
+
+  // double jumpSpeed = 25;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_jumpspeed = this->_internal_jumpspeed();
+  ::uint64_t raw_jumpspeed;
+  memcpy(&raw_jumpspeed, &tmp_jumpspeed, sizeof(tmp_jumpspeed));
+  if (raw_jumpspeed != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        25, this->_internal_jumpspeed(), target);
+  }
+
+  // double jumpSpeedMin = 26;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_jumpspeedmin = this->_internal_jumpspeedmin();
+  ::uint64_t raw_jumpspeedmin;
+  memcpy(&raw_jumpspeedmin, &tmp_jumpspeedmin, sizeof(tmp_jumpspeedmin));
+  if (raw_jumpspeedmin != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        26, this->_internal_jumpspeedmin(), target);
+  }
+
+  // double jumpSpeedMax = 27;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_jumpspeedmax = this->_internal_jumpspeedmax();
+  ::uint64_t raw_jumpspeedmax;
+  memcpy(&raw_jumpspeedmax, &tmp_jumpspeedmax, sizeof(tmp_jumpspeedmax));
+  if (raw_jumpspeedmax != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        27, this->_internal_jumpspeedmax(), target);
+  }
+
+  // double markSpeed = 28;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_markspeed = this->_internal_markspeed();
+  ::uint64_t raw_markspeed;
+  memcpy(&raw_markspeed, &tmp_markspeed, sizeof(tmp_markspeed));
+  if (raw_markspeed != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        28, this->_internal_markspeed(), target);
+  }
+
+  // double markSpeedMin = 29;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_markspeedmin = this->_internal_markspeedmin();
+  ::uint64_t raw_markspeedmin;
+  memcpy(&raw_markspeedmin, &tmp_markspeedmin, sizeof(tmp_markspeedmin));
+  if (raw_markspeedmin != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        29, this->_internal_markspeedmin(), target);
+  }
+
+  // double markSpeedMax = 30;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_markspeedmax = this->_internal_markspeedmax();
+  ::uint64_t raw_markspeedmax;
+  memcpy(&raw_markspeedmax, &tmp_markspeedmax, sizeof(tmp_markspeedmax));
+  if (raw_markspeedmax != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        30, this->_internal_markspeedmax(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target =
+        ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
+            _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:stream.ScanParamCfg)
+  return target;
+}
+
+::size_t ScanParamCfg::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:stream.ScanParamCfg)
+  ::size_t total_size = 0;
+
+  ::uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // int32 edgeLevel = 1;
+  if (this->_internal_edgelevel() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
+        this->_internal_edgelevel());
+  }
+
+  // int32 edgeLevelMin = 2;
+  if (this->_internal_edgelevelmin() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
+        this->_internal_edgelevelmin());
+  }
+
+  // int32 edgeLevelMax = 3;
+  if (this->_internal_edgelevelmax() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
+        this->_internal_edgelevelmax());
+  }
+
+  // uint32 jumpDelay = 4;
+  if (this->_internal_jumpdelay() != 0) {
+    total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
+        this->_internal_jumpdelay());
+  }
+
+  // uint32 jumpDelayMin = 5;
+  if (this->_internal_jumpdelaymin() != 0) {
+    total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
+        this->_internal_jumpdelaymin());
+  }
+
+  // uint32 jumpDelayMax = 6;
+  if (this->_internal_jumpdelaymax() != 0) {
+    total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
+        this->_internal_jumpdelaymax());
+  }
+
+  // uint32 scanDelay = 7;
+  if (this->_internal_scandelay() != 0) {
+    total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
+        this->_internal_scandelay());
+  }
+
+  // uint32 scanDelayMin = 8;
+  if (this->_internal_scandelaymin() != 0) {
+    total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
+        this->_internal_scandelaymin());
+  }
+
+  // uint32 scanDelayMax = 9;
+  if (this->_internal_scandelaymax() != 0) {
+    total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
+        this->_internal_scandelaymax());
+  }
+
+  // uint32 polygonDelay = 10;
+  if (this->_internal_polygondelay() != 0) {
+    total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
+        this->_internal_polygondelay());
+  }
+
+  // uint32 polygonDelayMin = 11;
+  if (this->_internal_polygondelaymin() != 0) {
+    total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
+        this->_internal_polygondelaymin());
+  }
+
+  // uint32 polygonDelayMax = 12;
+  if (this->_internal_polygondelaymax() != 0) {
+    total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
+        this->_internal_polygondelaymax());
+  }
+
+  // int64 laseroffDelay = 13;
+  if (this->_internal_laseroffdelay() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(
+        this->_internal_laseroffdelay());
+  }
+
+  // int64 laseroffDelayMin = 14;
+  if (this->_internal_laseroffdelaymin() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(
+        this->_internal_laseroffdelaymin());
+  }
+
+  // int64 laseroffDelayMax = 15;
+  if (this->_internal_laseroffdelaymax() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(
+        this->_internal_laseroffdelaymax());
+  }
+
+  // int64 laseronDelay = 16;
+  if (this->_internal_laserondelay() != 0) {
+    total_size += 2 + ::_pbi::WireFormatLite::Int64Size(
+                                    this->_internal_laserondelay());
+  }
+
+  // int64 laseronDelayMin = 17;
+  if (this->_internal_laserondelaymin() != 0) {
+    total_size += 2 + ::_pbi::WireFormatLite::Int64Size(
+                                    this->_internal_laserondelaymin());
+  }
+
+  // int64 laseronDelayMax = 18;
+  if (this->_internal_laserondelaymax() != 0) {
+    total_size += 2 + ::_pbi::WireFormatLite::Int64Size(
+                                    this->_internal_laserondelaymax());
+  }
+
+  // uint32 minJumpDelay = 19;
+  if (this->_internal_minjumpdelay() != 0) {
+    total_size += 2 + ::_pbi::WireFormatLite::UInt32Size(
+                                    this->_internal_minjumpdelay());
+  }
+
+  // uint32 minJumpDelayMin = 20;
+  if (this->_internal_minjumpdelaymin() != 0) {
+    total_size += 2 + ::_pbi::WireFormatLite::UInt32Size(
+                                    this->_internal_minjumpdelaymin());
+  }
+
+  // uint32 minJumpDelayMax = 21;
+  if (this->_internal_minjumpdelaymax() != 0) {
+    total_size += 2 + ::_pbi::WireFormatLite::UInt32Size(
+                                    this->_internal_minjumpdelaymax());
+  }
+
+  // uint32 jumpLengthLimit = 22;
+  if (this->_internal_jumplengthlimit() != 0) {
+    total_size += 2 + ::_pbi::WireFormatLite::UInt32Size(
+                                    this->_internal_jumplengthlimit());
+  }
+
+  // uint32 jumpLengthLimitMin = 23;
+  if (this->_internal_jumplengthlimitmin() != 0) {
+    total_size += 2 + ::_pbi::WireFormatLite::UInt32Size(
+                                    this->_internal_jumplengthlimitmin());
+  }
+
+  // uint32 jumpLengthLimitMax = 24;
+  if (this->_internal_jumplengthlimitmax() != 0) {
+    total_size += 2 + ::_pbi::WireFormatLite::UInt32Size(
+                                    this->_internal_jumplengthlimitmax());
+  }
+
+  // double jumpSpeed = 25;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_jumpspeed = this->_internal_jumpspeed();
+  ::uint64_t raw_jumpspeed;
+  memcpy(&raw_jumpspeed, &tmp_jumpspeed, sizeof(tmp_jumpspeed));
+  if (raw_jumpspeed != 0) {
+    total_size += 10;
+  }
+
+  // double jumpSpeedMin = 26;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_jumpspeedmin = this->_internal_jumpspeedmin();
+  ::uint64_t raw_jumpspeedmin;
+  memcpy(&raw_jumpspeedmin, &tmp_jumpspeedmin, sizeof(tmp_jumpspeedmin));
+  if (raw_jumpspeedmin != 0) {
+    total_size += 10;
+  }
+
+  // double jumpSpeedMax = 27;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_jumpspeedmax = this->_internal_jumpspeedmax();
+  ::uint64_t raw_jumpspeedmax;
+  memcpy(&raw_jumpspeedmax, &tmp_jumpspeedmax, sizeof(tmp_jumpspeedmax));
+  if (raw_jumpspeedmax != 0) {
+    total_size += 10;
+  }
+
+  // double markSpeed = 28;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_markspeed = this->_internal_markspeed();
+  ::uint64_t raw_markspeed;
+  memcpy(&raw_markspeed, &tmp_markspeed, sizeof(tmp_markspeed));
+  if (raw_markspeed != 0) {
+    total_size += 10;
+  }
+
+  // double markSpeedMin = 29;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_markspeedmin = this->_internal_markspeedmin();
+  ::uint64_t raw_markspeedmin;
+  memcpy(&raw_markspeedmin, &tmp_markspeedmin, sizeof(tmp_markspeedmin));
+  if (raw_markspeedmin != 0) {
+    total_size += 10;
+  }
+
+  // double markSpeedMax = 30;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_markspeedmax = this->_internal_markspeedmax();
+  ::uint64_t raw_markspeedmax;
+  memcpy(&raw_markspeedmax, &tmp_markspeedmax, sizeof(tmp_markspeedmax));
+  if (raw_markspeedmax != 0) {
+    total_size += 10;
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::google::protobuf::Message::ClassData ScanParamCfg::_class_data_ = {
+    ::google::protobuf::Message::CopyWithSourceCheck,
+    ScanParamCfg::MergeImpl
+};
+const ::google::protobuf::Message::ClassData*ScanParamCfg::GetClassData() const { return &_class_data_; }
+
+
+void ScanParamCfg::MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg) {
+  auto* const _this = static_cast<ScanParamCfg*>(&to_msg);
+  auto& from = static_cast<const ScanParamCfg&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:stream.ScanParamCfg)
+  ABSL_DCHECK_NE(&from, _this);
+  ::uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_edgelevel() != 0) {
+    _this->_internal_set_edgelevel(from._internal_edgelevel());
+  }
+  if (from._internal_edgelevelmin() != 0) {
+    _this->_internal_set_edgelevelmin(from._internal_edgelevelmin());
+  }
+  if (from._internal_edgelevelmax() != 0) {
+    _this->_internal_set_edgelevelmax(from._internal_edgelevelmax());
+  }
+  if (from._internal_jumpdelay() != 0) {
+    _this->_internal_set_jumpdelay(from._internal_jumpdelay());
+  }
+  if (from._internal_jumpdelaymin() != 0) {
+    _this->_internal_set_jumpdelaymin(from._internal_jumpdelaymin());
+  }
+  if (from._internal_jumpdelaymax() != 0) {
+    _this->_internal_set_jumpdelaymax(from._internal_jumpdelaymax());
+  }
+  if (from._internal_scandelay() != 0) {
+    _this->_internal_set_scandelay(from._internal_scandelay());
+  }
+  if (from._internal_scandelaymin() != 0) {
+    _this->_internal_set_scandelaymin(from._internal_scandelaymin());
+  }
+  if (from._internal_scandelaymax() != 0) {
+    _this->_internal_set_scandelaymax(from._internal_scandelaymax());
+  }
+  if (from._internal_polygondelay() != 0) {
+    _this->_internal_set_polygondelay(from._internal_polygondelay());
+  }
+  if (from._internal_polygondelaymin() != 0) {
+    _this->_internal_set_polygondelaymin(from._internal_polygondelaymin());
+  }
+  if (from._internal_polygondelaymax() != 0) {
+    _this->_internal_set_polygondelaymax(from._internal_polygondelaymax());
+  }
+  if (from._internal_laseroffdelay() != 0) {
+    _this->_internal_set_laseroffdelay(from._internal_laseroffdelay());
+  }
+  if (from._internal_laseroffdelaymin() != 0) {
+    _this->_internal_set_laseroffdelaymin(from._internal_laseroffdelaymin());
+  }
+  if (from._internal_laseroffdelaymax() != 0) {
+    _this->_internal_set_laseroffdelaymax(from._internal_laseroffdelaymax());
+  }
+  if (from._internal_laserondelay() != 0) {
+    _this->_internal_set_laserondelay(from._internal_laserondelay());
+  }
+  if (from._internal_laserondelaymin() != 0) {
+    _this->_internal_set_laserondelaymin(from._internal_laserondelaymin());
+  }
+  if (from._internal_laserondelaymax() != 0) {
+    _this->_internal_set_laserondelaymax(from._internal_laserondelaymax());
+  }
+  if (from._internal_minjumpdelay() != 0) {
+    _this->_internal_set_minjumpdelay(from._internal_minjumpdelay());
+  }
+  if (from._internal_minjumpdelaymin() != 0) {
+    _this->_internal_set_minjumpdelaymin(from._internal_minjumpdelaymin());
+  }
+  if (from._internal_minjumpdelaymax() != 0) {
+    _this->_internal_set_minjumpdelaymax(from._internal_minjumpdelaymax());
+  }
+  if (from._internal_jumplengthlimit() != 0) {
+    _this->_internal_set_jumplengthlimit(from._internal_jumplengthlimit());
+  }
+  if (from._internal_jumplengthlimitmin() != 0) {
+    _this->_internal_set_jumplengthlimitmin(from._internal_jumplengthlimitmin());
+  }
+  if (from._internal_jumplengthlimitmax() != 0) {
+    _this->_internal_set_jumplengthlimitmax(from._internal_jumplengthlimitmax());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_jumpspeed = from._internal_jumpspeed();
+  ::uint64_t raw_jumpspeed;
+  memcpy(&raw_jumpspeed, &tmp_jumpspeed, sizeof(tmp_jumpspeed));
+  if (raw_jumpspeed != 0) {
+    _this->_internal_set_jumpspeed(from._internal_jumpspeed());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_jumpspeedmin = from._internal_jumpspeedmin();
+  ::uint64_t raw_jumpspeedmin;
+  memcpy(&raw_jumpspeedmin, &tmp_jumpspeedmin, sizeof(tmp_jumpspeedmin));
+  if (raw_jumpspeedmin != 0) {
+    _this->_internal_set_jumpspeedmin(from._internal_jumpspeedmin());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_jumpspeedmax = from._internal_jumpspeedmax();
+  ::uint64_t raw_jumpspeedmax;
+  memcpy(&raw_jumpspeedmax, &tmp_jumpspeedmax, sizeof(tmp_jumpspeedmax));
+  if (raw_jumpspeedmax != 0) {
+    _this->_internal_set_jumpspeedmax(from._internal_jumpspeedmax());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_markspeed = from._internal_markspeed();
+  ::uint64_t raw_markspeed;
+  memcpy(&raw_markspeed, &tmp_markspeed, sizeof(tmp_markspeed));
+  if (raw_markspeed != 0) {
+    _this->_internal_set_markspeed(from._internal_markspeed());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_markspeedmin = from._internal_markspeedmin();
+  ::uint64_t raw_markspeedmin;
+  memcpy(&raw_markspeedmin, &tmp_markspeedmin, sizeof(tmp_markspeedmin));
+  if (raw_markspeedmin != 0) {
+    _this->_internal_set_markspeedmin(from._internal_markspeedmin());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_markspeedmax = from._internal_markspeedmax();
+  ::uint64_t raw_markspeedmax;
+  memcpy(&raw_markspeedmax, &tmp_markspeedmax, sizeof(tmp_markspeedmax));
+  if (raw_markspeedmax != 0) {
+    _this->_internal_set_markspeedmax(from._internal_markspeedmax());
+  }
+  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ScanParamCfg::CopyFrom(const ScanParamCfg& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:stream.ScanParamCfg)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+PROTOBUF_NOINLINE bool ScanParamCfg::IsInitialized() const {
+  return true;
+}
+
+void ScanParamCfg::InternalSwap(ScanParamCfg* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::google::protobuf::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.markspeedmax_)
+      + sizeof(ScanParamCfg::_impl_.markspeedmax_)
+      - PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.edgelevel_)>(
+          reinterpret_cast<char*>(&_impl_.edgelevel_),
+          reinterpret_cast<char*>(&other->_impl_.edgelevel_));
+}
+
+::google::protobuf::Metadata ScanParamCfg::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_stream_2eproto_getter, &descriptor_table_stream_2eproto_once,
+      file_level_metadata_stream_2eproto[15]);
+}
+// ===================================================================
+
+class CorrectParamCfg::_Internal {
+ public:
+};
+
+CorrectParamCfg::CorrectParamCfg(::google::protobuf::Arena* arena)
+    : ::google::protobuf::Message(arena) {
+  SharedCtor(arena);
+  // @@protoc_insertion_point(arena_constructor:stream.CorrectParamCfg)
+}
+CorrectParamCfg::CorrectParamCfg(const CorrectParamCfg& from)
+    : ::google::protobuf::Message(), _impl_(from._impl_) {
+  _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
+      from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:stream.CorrectParamCfg)
+}
+inline void CorrectParamCfg::SharedCtor(::_pb::Arena* arena) {
+  (void)arena;
+  new (&_impl_) Impl_{
+      decltype(_impl_.xmeasuremin_){0},
+      decltype(_impl_.xmeasuremax_){0},
+      decltype(_impl_.ymeasuremin_){0},
+      decltype(_impl_.ymeasuremax_){0},
+      decltype(_impl_.xposfix_){0},
+      decltype(_impl_.yposfix_){0},
+      decltype(_impl_.scanangle_){0},
+      decltype(_impl_.scananglemin_){0},
+      decltype(_impl_.scananglemax_){0},
+      decltype(_impl_.fixangle_){0},
+      decltype(_impl_.fixanglemin_){0},
+      decltype(_impl_.fixanglemax_){0},
+      decltype(_impl_.xcorrect_){0},
+      decltype(_impl_.ycorrect_){0},
+      decltype(_impl_.xcorrectmin_){0},
+      decltype(_impl_.xcorrectmax_){0},
+      decltype(_impl_.ycorrectmin_){0},
+      decltype(_impl_.ycorrectmax_){0},
+      decltype(_impl_.realxoffset_){0},
+      decltype(_impl_.realyoffset_){0},
+      decltype(_impl_.factork_){0},
+      decltype(_impl_.defocusratio_){0},
+      decltype(_impl_.defocusratiomin_){0},
+      decltype(_impl_.defocusratiomax_){0},
+      decltype(_impl_.iscorrectfile3d_){false},
+      decltype(_impl_.isdynamicfocus_){false},
+      /*decltype(_impl_._cached_size_)*/ {},
+  };
+}
+CorrectParamCfg::~CorrectParamCfg() {
+  // @@protoc_insertion_point(destructor:stream.CorrectParamCfg)
+  _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
+  SharedDtor();
+}
+inline void CorrectParamCfg::SharedDtor() {
+  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
+}
+void CorrectParamCfg::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+PROTOBUF_NOINLINE void CorrectParamCfg::Clear() {
+// @@protoc_insertion_point(message_clear_start:stream.CorrectParamCfg)
+  ::uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  ::memset(&_impl_.xmeasuremin_, 0, static_cast<::size_t>(
+      reinterpret_cast<char*>(&_impl_.isdynamicfocus_) -
+      reinterpret_cast<char*>(&_impl_.xmeasuremin_)) + sizeof(_impl_.isdynamicfocus_));
+  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
+}
+
+const char* CorrectParamCfg::_InternalParse(
+    const char* ptr, ::_pbi::ParseContext* ctx) {
+  ptr = ::_pbi::TcParser::ParseLoop(this, ptr, ctx, &_table_.header);
+  return ptr;
+}
+
+
+PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
+const ::_pbi::TcParseTable<5, 26, 0, 0, 2> CorrectParamCfg::_table_ = {
+  {
+    0,  // no _has_bits_
+    0, // no _extensions_
+    26, 248,  // max_field_number, fast_idx_mask
+    offsetof(decltype(_table_), field_lookup_table),
+    4227858432,  // skipmap
+    offsetof(decltype(_table_), field_entries),
+    26,  // num_field_entries
+    0,  // num_aux_entries
+    offsetof(decltype(_table_), field_names),  // no aux_entries
+    &_CorrectParamCfg_default_instance_._instance,
+    ::_pbi::TcParser::GenericFallback,  // fallback
+  }, {{
+    {::_pbi::TcParser::MiniParse, {}},
+    // double xmeasureMin = 1;
+    {::_pbi::TcParser::FastF64S1,
+     {9, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.xmeasuremin_)}},
+    // double xmeasureMax = 2;
+    {::_pbi::TcParser::FastF64S1,
+     {17, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.xmeasuremax_)}},
+    // double ymeasureMin = 3;
+    {::_pbi::TcParser::FastF64S1,
+     {25, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.ymeasuremin_)}},
+    // double ymeasureMax = 4;
+    {::_pbi::TcParser::FastF64S1,
+     {33, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.ymeasuremax_)}},
+    // double xposfix = 5;
+    {::_pbi::TcParser::FastF64S1,
+     {41, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.xposfix_)}},
+    // double yposfix = 6;
+    {::_pbi::TcParser::FastF64S1,
+     {49, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.yposfix_)}},
+    // double scanAngle = 7;
+    {::_pbi::TcParser::FastF64S1,
+     {57, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.scanangle_)}},
+    // double scanAngleMin = 8;
+    {::_pbi::TcParser::FastF64S1,
+     {65, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.scananglemin_)}},
+    // double scanAngleMax = 9;
+    {::_pbi::TcParser::FastF64S1,
+     {73, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.scananglemax_)}},
+    // double fixAngle = 10;
+    {::_pbi::TcParser::FastF64S1,
+     {81, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.fixangle_)}},
+    // double fixAngleMin = 11;
+    {::_pbi::TcParser::FastF64S1,
+     {89, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.fixanglemin_)}},
+    // double fixAngleMax = 12;
+    {::_pbi::TcParser::FastF64S1,
+     {97, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.fixanglemax_)}},
+    // double xcorrect = 13;
+    {::_pbi::TcParser::FastF64S1,
+     {105, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.xcorrect_)}},
+    // double ycorrect = 14;
+    {::_pbi::TcParser::FastF64S1,
+     {113, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.ycorrect_)}},
+    // double xcorrectMin = 15;
+    {::_pbi::TcParser::FastF64S1,
+     {121, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.xcorrectmin_)}},
+    // double xcorrectMax = 16;
+    {::_pbi::TcParser::FastF64S2,
+     {385, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.xcorrectmax_)}},
+    // double ycorrectMin = 17;
+    {::_pbi::TcParser::FastF64S2,
+     {393, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.ycorrectmin_)}},
+    // double ycorrectMax = 18;
+    {::_pbi::TcParser::FastF64S2,
+     {401, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.ycorrectmax_)}},
+    // double realXOffset = 19;
+    {::_pbi::TcParser::FastF64S2,
+     {409, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.realxoffset_)}},
+    // double realYOffset = 20;
+    {::_pbi::TcParser::FastF64S2,
+     {417, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.realyoffset_)}},
+    // double factorK = 21;
+    {::_pbi::TcParser::FastF64S2,
+     {425, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.factork_)}},
+    // bool isCorrectFile3D = 22;
+    {::_pbi::TcParser::FastV8S2,
+     {432, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.iscorrectfile3d_)}},
+    // bool isDynamicFocus = 23;
+    {::_pbi::TcParser::FastV8S2,
+     {440, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.isdynamicfocus_)}},
+    // double defocusRatio = 24;
+    {::_pbi::TcParser::FastF64S2,
+     {449, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.defocusratio_)}},
+    // double defocusRatioMin = 25;
+    {::_pbi::TcParser::FastF64S2,
+     {457, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.defocusratiomin_)}},
+    // double defocusRatioMax = 26;
+    {::_pbi::TcParser::FastF64S2,
+     {465, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.defocusratiomax_)}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+  }}, {{
+    65535, 65535
+  }}, {{
+    // double xmeasureMin = 1;
+    {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.xmeasuremin_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double xmeasureMax = 2;
+    {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.xmeasuremax_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double ymeasureMin = 3;
+    {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.ymeasuremin_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double ymeasureMax = 4;
+    {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.ymeasuremax_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double xposfix = 5;
+    {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.xposfix_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double yposfix = 6;
+    {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.yposfix_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double scanAngle = 7;
+    {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.scanangle_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double scanAngleMin = 8;
+    {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.scananglemin_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double scanAngleMax = 9;
+    {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.scananglemax_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double fixAngle = 10;
+    {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.fixangle_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double fixAngleMin = 11;
+    {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.fixanglemin_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double fixAngleMax = 12;
+    {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.fixanglemax_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double xcorrect = 13;
+    {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.xcorrect_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double ycorrect = 14;
+    {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.ycorrect_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double xcorrectMin = 15;
+    {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.xcorrectmin_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double xcorrectMax = 16;
+    {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.xcorrectmax_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double ycorrectMin = 17;
+    {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.ycorrectmin_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double ycorrectMax = 18;
+    {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.ycorrectmax_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double realXOffset = 19;
+    {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.realxoffset_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double realYOffset = 20;
+    {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.realyoffset_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double factorK = 21;
+    {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.factork_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // bool isCorrectFile3D = 22;
+    {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.iscorrectfile3d_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kBool)},
+    // bool isDynamicFocus = 23;
+    {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.isdynamicfocus_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kBool)},
+    // double defocusRatio = 24;
+    {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.defocusratio_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double defocusRatioMin = 25;
+    {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.defocusratiomin_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double defocusRatioMax = 26;
+    {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.defocusratiomax_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+  }},
+  // no aux_entries
+  {{
+  }},
+};
+
+::uint8_t* CorrectParamCfg::_InternalSerialize(
+    ::uint8_t* target,
+    ::google::protobuf::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:stream.CorrectParamCfg)
+  ::uint32_t cached_has_bits = 0;
+  (void)cached_has_bits;
+
+  // double xmeasureMin = 1;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_xmeasuremin = this->_internal_xmeasuremin();
+  ::uint64_t raw_xmeasuremin;
+  memcpy(&raw_xmeasuremin, &tmp_xmeasuremin, sizeof(tmp_xmeasuremin));
+  if (raw_xmeasuremin != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        1, this->_internal_xmeasuremin(), target);
+  }
+
+  // double xmeasureMax = 2;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_xmeasuremax = this->_internal_xmeasuremax();
+  ::uint64_t raw_xmeasuremax;
+  memcpy(&raw_xmeasuremax, &tmp_xmeasuremax, sizeof(tmp_xmeasuremax));
+  if (raw_xmeasuremax != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        2, this->_internal_xmeasuremax(), target);
+  }
+
+  // double ymeasureMin = 3;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_ymeasuremin = this->_internal_ymeasuremin();
+  ::uint64_t raw_ymeasuremin;
+  memcpy(&raw_ymeasuremin, &tmp_ymeasuremin, sizeof(tmp_ymeasuremin));
+  if (raw_ymeasuremin != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        3, this->_internal_ymeasuremin(), target);
+  }
+
+  // double ymeasureMax = 4;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_ymeasuremax = this->_internal_ymeasuremax();
+  ::uint64_t raw_ymeasuremax;
+  memcpy(&raw_ymeasuremax, &tmp_ymeasuremax, sizeof(tmp_ymeasuremax));
+  if (raw_ymeasuremax != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        4, this->_internal_ymeasuremax(), target);
+  }
+
+  // double xposfix = 5;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_xposfix = this->_internal_xposfix();
+  ::uint64_t raw_xposfix;
+  memcpy(&raw_xposfix, &tmp_xposfix, sizeof(tmp_xposfix));
+  if (raw_xposfix != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        5, this->_internal_xposfix(), target);
+  }
+
+  // double yposfix = 6;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_yposfix = this->_internal_yposfix();
+  ::uint64_t raw_yposfix;
+  memcpy(&raw_yposfix, &tmp_yposfix, sizeof(tmp_yposfix));
+  if (raw_yposfix != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        6, this->_internal_yposfix(), target);
+  }
+
+  // double scanAngle = 7;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_scanangle = this->_internal_scanangle();
+  ::uint64_t raw_scanangle;
+  memcpy(&raw_scanangle, &tmp_scanangle, sizeof(tmp_scanangle));
+  if (raw_scanangle != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        7, this->_internal_scanangle(), target);
+  }
+
+  // double scanAngleMin = 8;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_scananglemin = this->_internal_scananglemin();
+  ::uint64_t raw_scananglemin;
+  memcpy(&raw_scananglemin, &tmp_scananglemin, sizeof(tmp_scananglemin));
+  if (raw_scananglemin != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        8, this->_internal_scananglemin(), target);
+  }
+
+  // double scanAngleMax = 9;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_scananglemax = this->_internal_scananglemax();
+  ::uint64_t raw_scananglemax;
+  memcpy(&raw_scananglemax, &tmp_scananglemax, sizeof(tmp_scananglemax));
+  if (raw_scananglemax != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        9, this->_internal_scananglemax(), target);
+  }
+
+  // double fixAngle = 10;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_fixangle = this->_internal_fixangle();
+  ::uint64_t raw_fixangle;
+  memcpy(&raw_fixangle, &tmp_fixangle, sizeof(tmp_fixangle));
+  if (raw_fixangle != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        10, this->_internal_fixangle(), target);
+  }
+
+  // double fixAngleMin = 11;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_fixanglemin = this->_internal_fixanglemin();
+  ::uint64_t raw_fixanglemin;
+  memcpy(&raw_fixanglemin, &tmp_fixanglemin, sizeof(tmp_fixanglemin));
+  if (raw_fixanglemin != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        11, this->_internal_fixanglemin(), target);
+  }
+
+  // double fixAngleMax = 12;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_fixanglemax = this->_internal_fixanglemax();
+  ::uint64_t raw_fixanglemax;
+  memcpy(&raw_fixanglemax, &tmp_fixanglemax, sizeof(tmp_fixanglemax));
+  if (raw_fixanglemax != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        12, this->_internal_fixanglemax(), target);
+  }
+
+  // double xcorrect = 13;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_xcorrect = this->_internal_xcorrect();
+  ::uint64_t raw_xcorrect;
+  memcpy(&raw_xcorrect, &tmp_xcorrect, sizeof(tmp_xcorrect));
+  if (raw_xcorrect != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        13, this->_internal_xcorrect(), target);
+  }
+
+  // double ycorrect = 14;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_ycorrect = this->_internal_ycorrect();
+  ::uint64_t raw_ycorrect;
+  memcpy(&raw_ycorrect, &tmp_ycorrect, sizeof(tmp_ycorrect));
+  if (raw_ycorrect != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        14, this->_internal_ycorrect(), target);
+  }
+
+  // double xcorrectMin = 15;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_xcorrectmin = this->_internal_xcorrectmin();
+  ::uint64_t raw_xcorrectmin;
+  memcpy(&raw_xcorrectmin, &tmp_xcorrectmin, sizeof(tmp_xcorrectmin));
+  if (raw_xcorrectmin != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        15, this->_internal_xcorrectmin(), target);
+  }
+
+  // double xcorrectMax = 16;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_xcorrectmax = this->_internal_xcorrectmax();
+  ::uint64_t raw_xcorrectmax;
+  memcpy(&raw_xcorrectmax, &tmp_xcorrectmax, sizeof(tmp_xcorrectmax));
+  if (raw_xcorrectmax != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        16, this->_internal_xcorrectmax(), target);
+  }
+
+  // double ycorrectMin = 17;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_ycorrectmin = this->_internal_ycorrectmin();
+  ::uint64_t raw_ycorrectmin;
+  memcpy(&raw_ycorrectmin, &tmp_ycorrectmin, sizeof(tmp_ycorrectmin));
+  if (raw_ycorrectmin != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        17, this->_internal_ycorrectmin(), target);
+  }
+
+  // double ycorrectMax = 18;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_ycorrectmax = this->_internal_ycorrectmax();
+  ::uint64_t raw_ycorrectmax;
+  memcpy(&raw_ycorrectmax, &tmp_ycorrectmax, sizeof(tmp_ycorrectmax));
+  if (raw_ycorrectmax != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        18, this->_internal_ycorrectmax(), target);
+  }
+
+  // double realXOffset = 19;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_realxoffset = this->_internal_realxoffset();
+  ::uint64_t raw_realxoffset;
+  memcpy(&raw_realxoffset, &tmp_realxoffset, sizeof(tmp_realxoffset));
+  if (raw_realxoffset != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        19, this->_internal_realxoffset(), target);
+  }
+
+  // double realYOffset = 20;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_realyoffset = this->_internal_realyoffset();
+  ::uint64_t raw_realyoffset;
+  memcpy(&raw_realyoffset, &tmp_realyoffset, sizeof(tmp_realyoffset));
+  if (raw_realyoffset != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        20, this->_internal_realyoffset(), target);
+  }
+
+  // double factorK = 21;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_factork = this->_internal_factork();
+  ::uint64_t raw_factork;
+  memcpy(&raw_factork, &tmp_factork, sizeof(tmp_factork));
+  if (raw_factork != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        21, this->_internal_factork(), target);
+  }
+
+  // bool isCorrectFile3D = 22;
+  if (this->_internal_iscorrectfile3d() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(
+        22, this->_internal_iscorrectfile3d(), target);
+  }
+
+  // bool isDynamicFocus = 23;
+  if (this->_internal_isdynamicfocus() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(
+        23, this->_internal_isdynamicfocus(), target);
+  }
+
+  // double defocusRatio = 24;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_defocusratio = this->_internal_defocusratio();
+  ::uint64_t raw_defocusratio;
+  memcpy(&raw_defocusratio, &tmp_defocusratio, sizeof(tmp_defocusratio));
+  if (raw_defocusratio != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        24, this->_internal_defocusratio(), target);
+  }
+
+  // double defocusRatioMin = 25;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_defocusratiomin = this->_internal_defocusratiomin();
+  ::uint64_t raw_defocusratiomin;
+  memcpy(&raw_defocusratiomin, &tmp_defocusratiomin, sizeof(tmp_defocusratiomin));
+  if (raw_defocusratiomin != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        25, this->_internal_defocusratiomin(), target);
+  }
+
+  // double defocusRatioMax = 26;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_defocusratiomax = this->_internal_defocusratiomax();
+  ::uint64_t raw_defocusratiomax;
+  memcpy(&raw_defocusratiomax, &tmp_defocusratiomax, sizeof(tmp_defocusratiomax));
+  if (raw_defocusratiomax != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        26, this->_internal_defocusratiomax(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target =
+        ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
+            _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:stream.CorrectParamCfg)
+  return target;
+}
+
+::size_t CorrectParamCfg::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:stream.CorrectParamCfg)
+  ::size_t total_size = 0;
+
+  ::uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // double xmeasureMin = 1;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_xmeasuremin = this->_internal_xmeasuremin();
+  ::uint64_t raw_xmeasuremin;
+  memcpy(&raw_xmeasuremin, &tmp_xmeasuremin, sizeof(tmp_xmeasuremin));
+  if (raw_xmeasuremin != 0) {
+    total_size += 9;
+  }
+
+  // double xmeasureMax = 2;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_xmeasuremax = this->_internal_xmeasuremax();
+  ::uint64_t raw_xmeasuremax;
+  memcpy(&raw_xmeasuremax, &tmp_xmeasuremax, sizeof(tmp_xmeasuremax));
+  if (raw_xmeasuremax != 0) {
+    total_size += 9;
+  }
+
+  // double ymeasureMin = 3;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_ymeasuremin = this->_internal_ymeasuremin();
+  ::uint64_t raw_ymeasuremin;
+  memcpy(&raw_ymeasuremin, &tmp_ymeasuremin, sizeof(tmp_ymeasuremin));
+  if (raw_ymeasuremin != 0) {
+    total_size += 9;
+  }
+
+  // double ymeasureMax = 4;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_ymeasuremax = this->_internal_ymeasuremax();
+  ::uint64_t raw_ymeasuremax;
+  memcpy(&raw_ymeasuremax, &tmp_ymeasuremax, sizeof(tmp_ymeasuremax));
+  if (raw_ymeasuremax != 0) {
+    total_size += 9;
+  }
+
+  // double xposfix = 5;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_xposfix = this->_internal_xposfix();
+  ::uint64_t raw_xposfix;
+  memcpy(&raw_xposfix, &tmp_xposfix, sizeof(tmp_xposfix));
+  if (raw_xposfix != 0) {
+    total_size += 9;
+  }
+
+  // double yposfix = 6;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_yposfix = this->_internal_yposfix();
+  ::uint64_t raw_yposfix;
+  memcpy(&raw_yposfix, &tmp_yposfix, sizeof(tmp_yposfix));
+  if (raw_yposfix != 0) {
+    total_size += 9;
+  }
+
+  // double scanAngle = 7;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_scanangle = this->_internal_scanangle();
+  ::uint64_t raw_scanangle;
+  memcpy(&raw_scanangle, &tmp_scanangle, sizeof(tmp_scanangle));
+  if (raw_scanangle != 0) {
+    total_size += 9;
+  }
+
+  // double scanAngleMin = 8;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_scananglemin = this->_internal_scananglemin();
+  ::uint64_t raw_scananglemin;
+  memcpy(&raw_scananglemin, &tmp_scananglemin, sizeof(tmp_scananglemin));
+  if (raw_scananglemin != 0) {
+    total_size += 9;
+  }
+
+  // double scanAngleMax = 9;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_scananglemax = this->_internal_scananglemax();
+  ::uint64_t raw_scananglemax;
+  memcpy(&raw_scananglemax, &tmp_scananglemax, sizeof(tmp_scananglemax));
+  if (raw_scananglemax != 0) {
+    total_size += 9;
+  }
+
+  // double fixAngle = 10;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_fixangle = this->_internal_fixangle();
+  ::uint64_t raw_fixangle;
+  memcpy(&raw_fixangle, &tmp_fixangle, sizeof(tmp_fixangle));
+  if (raw_fixangle != 0) {
+    total_size += 9;
+  }
+
+  // double fixAngleMin = 11;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_fixanglemin = this->_internal_fixanglemin();
+  ::uint64_t raw_fixanglemin;
+  memcpy(&raw_fixanglemin, &tmp_fixanglemin, sizeof(tmp_fixanglemin));
+  if (raw_fixanglemin != 0) {
+    total_size += 9;
+  }
+
+  // double fixAngleMax = 12;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_fixanglemax = this->_internal_fixanglemax();
+  ::uint64_t raw_fixanglemax;
+  memcpy(&raw_fixanglemax, &tmp_fixanglemax, sizeof(tmp_fixanglemax));
+  if (raw_fixanglemax != 0) {
+    total_size += 9;
+  }
+
+  // double xcorrect = 13;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_xcorrect = this->_internal_xcorrect();
+  ::uint64_t raw_xcorrect;
+  memcpy(&raw_xcorrect, &tmp_xcorrect, sizeof(tmp_xcorrect));
+  if (raw_xcorrect != 0) {
+    total_size += 9;
+  }
+
+  // double ycorrect = 14;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_ycorrect = this->_internal_ycorrect();
+  ::uint64_t raw_ycorrect;
+  memcpy(&raw_ycorrect, &tmp_ycorrect, sizeof(tmp_ycorrect));
+  if (raw_ycorrect != 0) {
+    total_size += 9;
+  }
+
+  // double xcorrectMin = 15;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_xcorrectmin = this->_internal_xcorrectmin();
+  ::uint64_t raw_xcorrectmin;
+  memcpy(&raw_xcorrectmin, &tmp_xcorrectmin, sizeof(tmp_xcorrectmin));
+  if (raw_xcorrectmin != 0) {
+    total_size += 9;
+  }
+
+  // double xcorrectMax = 16;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_xcorrectmax = this->_internal_xcorrectmax();
+  ::uint64_t raw_xcorrectmax;
+  memcpy(&raw_xcorrectmax, &tmp_xcorrectmax, sizeof(tmp_xcorrectmax));
+  if (raw_xcorrectmax != 0) {
+    total_size += 10;
+  }
+
+  // double ycorrectMin = 17;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_ycorrectmin = this->_internal_ycorrectmin();
+  ::uint64_t raw_ycorrectmin;
+  memcpy(&raw_ycorrectmin, &tmp_ycorrectmin, sizeof(tmp_ycorrectmin));
+  if (raw_ycorrectmin != 0) {
+    total_size += 10;
+  }
+
+  // double ycorrectMax = 18;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_ycorrectmax = this->_internal_ycorrectmax();
+  ::uint64_t raw_ycorrectmax;
+  memcpy(&raw_ycorrectmax, &tmp_ycorrectmax, sizeof(tmp_ycorrectmax));
+  if (raw_ycorrectmax != 0) {
+    total_size += 10;
+  }
+
+  // double realXOffset = 19;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_realxoffset = this->_internal_realxoffset();
+  ::uint64_t raw_realxoffset;
+  memcpy(&raw_realxoffset, &tmp_realxoffset, sizeof(tmp_realxoffset));
+  if (raw_realxoffset != 0) {
+    total_size += 10;
+  }
+
+  // double realYOffset = 20;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_realyoffset = this->_internal_realyoffset();
+  ::uint64_t raw_realyoffset;
+  memcpy(&raw_realyoffset, &tmp_realyoffset, sizeof(tmp_realyoffset));
+  if (raw_realyoffset != 0) {
+    total_size += 10;
+  }
+
+  // double factorK = 21;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_factork = this->_internal_factork();
+  ::uint64_t raw_factork;
+  memcpy(&raw_factork, &tmp_factork, sizeof(tmp_factork));
+  if (raw_factork != 0) {
+    total_size += 10;
+  }
+
+  // double defocusRatio = 24;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_defocusratio = this->_internal_defocusratio();
+  ::uint64_t raw_defocusratio;
+  memcpy(&raw_defocusratio, &tmp_defocusratio, sizeof(tmp_defocusratio));
+  if (raw_defocusratio != 0) {
+    total_size += 10;
+  }
+
+  // double defocusRatioMin = 25;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_defocusratiomin = this->_internal_defocusratiomin();
+  ::uint64_t raw_defocusratiomin;
+  memcpy(&raw_defocusratiomin, &tmp_defocusratiomin, sizeof(tmp_defocusratiomin));
+  if (raw_defocusratiomin != 0) {
+    total_size += 10;
+  }
+
+  // double defocusRatioMax = 26;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_defocusratiomax = this->_internal_defocusratiomax();
+  ::uint64_t raw_defocusratiomax;
+  memcpy(&raw_defocusratiomax, &tmp_defocusratiomax, sizeof(tmp_defocusratiomax));
+  if (raw_defocusratiomax != 0) {
+    total_size += 10;
+  }
+
+  // bool isCorrectFile3D = 22;
+  if (this->_internal_iscorrectfile3d() != 0) {
+    total_size += 3;
+  }
+
+  // bool isDynamicFocus = 23;
+  if (this->_internal_isdynamicfocus() != 0) {
+    total_size += 3;
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::google::protobuf::Message::ClassData CorrectParamCfg::_class_data_ = {
+    ::google::protobuf::Message::CopyWithSourceCheck,
+    CorrectParamCfg::MergeImpl
+};
+const ::google::protobuf::Message::ClassData*CorrectParamCfg::GetClassData() const { return &_class_data_; }
+
+
+void CorrectParamCfg::MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg) {
+  auto* const _this = static_cast<CorrectParamCfg*>(&to_msg);
+  auto& from = static_cast<const CorrectParamCfg&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:stream.CorrectParamCfg)
+  ABSL_DCHECK_NE(&from, _this);
+  ::uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_xmeasuremin = from._internal_xmeasuremin();
+  ::uint64_t raw_xmeasuremin;
+  memcpy(&raw_xmeasuremin, &tmp_xmeasuremin, sizeof(tmp_xmeasuremin));
+  if (raw_xmeasuremin != 0) {
+    _this->_internal_set_xmeasuremin(from._internal_xmeasuremin());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_xmeasuremax = from._internal_xmeasuremax();
+  ::uint64_t raw_xmeasuremax;
+  memcpy(&raw_xmeasuremax, &tmp_xmeasuremax, sizeof(tmp_xmeasuremax));
+  if (raw_xmeasuremax != 0) {
+    _this->_internal_set_xmeasuremax(from._internal_xmeasuremax());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_ymeasuremin = from._internal_ymeasuremin();
+  ::uint64_t raw_ymeasuremin;
+  memcpy(&raw_ymeasuremin, &tmp_ymeasuremin, sizeof(tmp_ymeasuremin));
+  if (raw_ymeasuremin != 0) {
+    _this->_internal_set_ymeasuremin(from._internal_ymeasuremin());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_ymeasuremax = from._internal_ymeasuremax();
+  ::uint64_t raw_ymeasuremax;
+  memcpy(&raw_ymeasuremax, &tmp_ymeasuremax, sizeof(tmp_ymeasuremax));
+  if (raw_ymeasuremax != 0) {
+    _this->_internal_set_ymeasuremax(from._internal_ymeasuremax());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_xposfix = from._internal_xposfix();
+  ::uint64_t raw_xposfix;
+  memcpy(&raw_xposfix, &tmp_xposfix, sizeof(tmp_xposfix));
+  if (raw_xposfix != 0) {
+    _this->_internal_set_xposfix(from._internal_xposfix());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_yposfix = from._internal_yposfix();
+  ::uint64_t raw_yposfix;
+  memcpy(&raw_yposfix, &tmp_yposfix, sizeof(tmp_yposfix));
+  if (raw_yposfix != 0) {
+    _this->_internal_set_yposfix(from._internal_yposfix());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_scanangle = from._internal_scanangle();
+  ::uint64_t raw_scanangle;
+  memcpy(&raw_scanangle, &tmp_scanangle, sizeof(tmp_scanangle));
+  if (raw_scanangle != 0) {
+    _this->_internal_set_scanangle(from._internal_scanangle());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_scananglemin = from._internal_scananglemin();
+  ::uint64_t raw_scananglemin;
+  memcpy(&raw_scananglemin, &tmp_scananglemin, sizeof(tmp_scananglemin));
+  if (raw_scananglemin != 0) {
+    _this->_internal_set_scananglemin(from._internal_scananglemin());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_scananglemax = from._internal_scananglemax();
+  ::uint64_t raw_scananglemax;
+  memcpy(&raw_scananglemax, &tmp_scananglemax, sizeof(tmp_scananglemax));
+  if (raw_scananglemax != 0) {
+    _this->_internal_set_scananglemax(from._internal_scananglemax());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_fixangle = from._internal_fixangle();
+  ::uint64_t raw_fixangle;
+  memcpy(&raw_fixangle, &tmp_fixangle, sizeof(tmp_fixangle));
+  if (raw_fixangle != 0) {
+    _this->_internal_set_fixangle(from._internal_fixangle());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_fixanglemin = from._internal_fixanglemin();
+  ::uint64_t raw_fixanglemin;
+  memcpy(&raw_fixanglemin, &tmp_fixanglemin, sizeof(tmp_fixanglemin));
+  if (raw_fixanglemin != 0) {
+    _this->_internal_set_fixanglemin(from._internal_fixanglemin());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_fixanglemax = from._internal_fixanglemax();
+  ::uint64_t raw_fixanglemax;
+  memcpy(&raw_fixanglemax, &tmp_fixanglemax, sizeof(tmp_fixanglemax));
+  if (raw_fixanglemax != 0) {
+    _this->_internal_set_fixanglemax(from._internal_fixanglemax());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_xcorrect = from._internal_xcorrect();
+  ::uint64_t raw_xcorrect;
+  memcpy(&raw_xcorrect, &tmp_xcorrect, sizeof(tmp_xcorrect));
+  if (raw_xcorrect != 0) {
+    _this->_internal_set_xcorrect(from._internal_xcorrect());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_ycorrect = from._internal_ycorrect();
+  ::uint64_t raw_ycorrect;
+  memcpy(&raw_ycorrect, &tmp_ycorrect, sizeof(tmp_ycorrect));
+  if (raw_ycorrect != 0) {
+    _this->_internal_set_ycorrect(from._internal_ycorrect());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_xcorrectmin = from._internal_xcorrectmin();
+  ::uint64_t raw_xcorrectmin;
+  memcpy(&raw_xcorrectmin, &tmp_xcorrectmin, sizeof(tmp_xcorrectmin));
+  if (raw_xcorrectmin != 0) {
+    _this->_internal_set_xcorrectmin(from._internal_xcorrectmin());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_xcorrectmax = from._internal_xcorrectmax();
+  ::uint64_t raw_xcorrectmax;
+  memcpy(&raw_xcorrectmax, &tmp_xcorrectmax, sizeof(tmp_xcorrectmax));
+  if (raw_xcorrectmax != 0) {
+    _this->_internal_set_xcorrectmax(from._internal_xcorrectmax());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_ycorrectmin = from._internal_ycorrectmin();
+  ::uint64_t raw_ycorrectmin;
+  memcpy(&raw_ycorrectmin, &tmp_ycorrectmin, sizeof(tmp_ycorrectmin));
+  if (raw_ycorrectmin != 0) {
+    _this->_internal_set_ycorrectmin(from._internal_ycorrectmin());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_ycorrectmax = from._internal_ycorrectmax();
+  ::uint64_t raw_ycorrectmax;
+  memcpy(&raw_ycorrectmax, &tmp_ycorrectmax, sizeof(tmp_ycorrectmax));
+  if (raw_ycorrectmax != 0) {
+    _this->_internal_set_ycorrectmax(from._internal_ycorrectmax());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_realxoffset = from._internal_realxoffset();
+  ::uint64_t raw_realxoffset;
+  memcpy(&raw_realxoffset, &tmp_realxoffset, sizeof(tmp_realxoffset));
+  if (raw_realxoffset != 0) {
+    _this->_internal_set_realxoffset(from._internal_realxoffset());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_realyoffset = from._internal_realyoffset();
+  ::uint64_t raw_realyoffset;
+  memcpy(&raw_realyoffset, &tmp_realyoffset, sizeof(tmp_realyoffset));
+  if (raw_realyoffset != 0) {
+    _this->_internal_set_realyoffset(from._internal_realyoffset());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_factork = from._internal_factork();
+  ::uint64_t raw_factork;
+  memcpy(&raw_factork, &tmp_factork, sizeof(tmp_factork));
+  if (raw_factork != 0) {
+    _this->_internal_set_factork(from._internal_factork());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_defocusratio = from._internal_defocusratio();
+  ::uint64_t raw_defocusratio;
+  memcpy(&raw_defocusratio, &tmp_defocusratio, sizeof(tmp_defocusratio));
+  if (raw_defocusratio != 0) {
+    _this->_internal_set_defocusratio(from._internal_defocusratio());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_defocusratiomin = from._internal_defocusratiomin();
+  ::uint64_t raw_defocusratiomin;
+  memcpy(&raw_defocusratiomin, &tmp_defocusratiomin, sizeof(tmp_defocusratiomin));
+  if (raw_defocusratiomin != 0) {
+    _this->_internal_set_defocusratiomin(from._internal_defocusratiomin());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_defocusratiomax = from._internal_defocusratiomax();
+  ::uint64_t raw_defocusratiomax;
+  memcpy(&raw_defocusratiomax, &tmp_defocusratiomax, sizeof(tmp_defocusratiomax));
+  if (raw_defocusratiomax != 0) {
+    _this->_internal_set_defocusratiomax(from._internal_defocusratiomax());
+  }
+  if (from._internal_iscorrectfile3d() != 0) {
+    _this->_internal_set_iscorrectfile3d(from._internal_iscorrectfile3d());
+  }
+  if (from._internal_isdynamicfocus() != 0) {
+    _this->_internal_set_isdynamicfocus(from._internal_isdynamicfocus());
+  }
+  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void CorrectParamCfg::CopyFrom(const CorrectParamCfg& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:stream.CorrectParamCfg)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+PROTOBUF_NOINLINE bool CorrectParamCfg::IsInitialized() const {
+  return true;
+}
+
+void CorrectParamCfg::InternalSwap(CorrectParamCfg* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::google::protobuf::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.isdynamicfocus_)
+      + sizeof(CorrectParamCfg::_impl_.isdynamicfocus_)
+      - PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.xmeasuremin_)>(
+          reinterpret_cast<char*>(&_impl_.xmeasuremin_),
+          reinterpret_cast<char*>(&other->_impl_.xmeasuremin_));
+}
+
+::google::protobuf::Metadata CorrectParamCfg::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_stream_2eproto_getter, &descriptor_table_stream_2eproto_once,
+      file_level_metadata_stream_2eproto[16]);
+}
+// ===================================================================
+
+class ScanTestCfg::_Internal {
+ public:
+};
+
+ScanTestCfg::ScanTestCfg(::google::protobuf::Arena* arena)
+    : ::google::protobuf::Message(arena) {
+  SharedCtor(arena);
+  // @@protoc_insertion_point(arena_constructor:stream.ScanTestCfg)
+}
+ScanTestCfg::ScanTestCfg(const ScanTestCfg& from)
+    : ::google::protobuf::Message(), _impl_(from._impl_) {
+  _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
+      from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:stream.ScanTestCfg)
+}
+inline void ScanTestCfg::SharedCtor(::_pb::Arena* arena) {
+  (void)arena;
+  new (&_impl_) Impl_{
+      decltype(_impl_.debugshape_){0},
+      decltype(_impl_.shapesize_){0},
+      decltype(_impl_.shapesizemin_){0},
+      decltype(_impl_.shape_size_max_){0},
+      decltype(_impl_.laser_power_){0},
+      decltype(_impl_.laser_power_min_){0},
+      decltype(_impl_.defocus_){0},
+      decltype(_impl_.defocus_min_){0},
+      decltype(_impl_.defocus_max_){0},
+      decltype(_impl_.laser_power_max_){0},
+      decltype(_impl_.is_cycle_){false},
+      decltype(_impl_.isautoheatingscanner_){false},
+      decltype(_impl_.cross_x_){0},
+      decltype(_impl_.cross_y_){0},
+      decltype(_impl_.z_distance_){0},
+      decltype(_impl_.autoheatingscannerminutes_){0u},
+      decltype(_impl_.autoheatingscannersize_){0u},
+      decltype(_impl_.autoheatingscannerspeed_){0},
+      decltype(_impl_.mark_test_start_x_){0},
+      decltype(_impl_.mark_test_start_y_){0},
+      decltype(_impl_.mark_test_end_x_){0},
+      decltype(_impl_.mark_test_end_y_){0},
+      /*decltype(_impl_._cached_size_)*/ {},
+  };
+}
+ScanTestCfg::~ScanTestCfg() {
+  // @@protoc_insertion_point(destructor:stream.ScanTestCfg)
+  _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
+  SharedDtor();
+}
+inline void ScanTestCfg::SharedDtor() {
+  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
+}
+void ScanTestCfg::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+PROTOBUF_NOINLINE void ScanTestCfg::Clear() {
+// @@protoc_insertion_point(message_clear_start:stream.ScanTestCfg)
+  ::uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  ::memset(&_impl_.debugshape_, 0, static_cast<::size_t>(
+      reinterpret_cast<char*>(&_impl_.mark_test_end_y_) -
+      reinterpret_cast<char*>(&_impl_.debugshape_)) + sizeof(_impl_.mark_test_end_y_));
+  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
+}
+
+const char* ScanTestCfg::_InternalParse(
+    const char* ptr, ::_pbi::ParseContext* ctx) {
+  ptr = ::_pbi::TcParser::ParseLoop(this, ptr, ctx, &_table_.header);
+  return ptr;
+}
+
+
+PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
+const ::_pbi::TcParseTable<5, 22, 0, 0, 2> ScanTestCfg::_table_ = {
+  {
+    0,  // no _has_bits_
+    0, // no _extensions_
+    22, 248,  // max_field_number, fast_idx_mask
+    offsetof(decltype(_table_), field_lookup_table),
+    4290772992,  // skipmap
+    offsetof(decltype(_table_), field_entries),
+    22,  // num_field_entries
+    0,  // num_aux_entries
+    offsetof(decltype(_table_), field_names),  // no aux_entries
+    &_ScanTestCfg_default_instance_._instance,
+    ::_pbi::TcParser::GenericFallback,  // fallback
+  }, {{
+    {::_pbi::TcParser::MiniParse, {}},
+    // int32 debugShape = 1;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanTestCfg, _impl_.debugshape_), 63>(),
+     {8, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.debugshape_)}},
+    // int32 shapeSize = 2;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanTestCfg, _impl_.shapesize_), 63>(),
+     {16, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.shapesize_)}},
+    // int32 shapeSizeMin = 3;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanTestCfg, _impl_.shapesizemin_), 63>(),
+     {24, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.shapesizemin_)}},
+    // int32 shape_size_max = 4;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanTestCfg, _impl_.shape_size_max_), 63>(),
+     {32, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.shape_size_max_)}},
+    // int32 laser_power = 5;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanTestCfg, _impl_.laser_power_), 63>(),
+     {40, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.laser_power_)}},
+    // int32 laser_power_min = 6;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanTestCfg, _impl_.laser_power_min_), 63>(),
+     {48, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.laser_power_min_)}},
+    // int32 laser_power_max = 7;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanTestCfg, _impl_.laser_power_max_), 63>(),
+     {56, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.laser_power_max_)}},
+    // double defocus = 8;
+    {::_pbi::TcParser::FastF64S1,
+     {65, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.defocus_)}},
+    // double defocus_min = 9;
+    {::_pbi::TcParser::FastF64S1,
+     {73, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.defocus_min_)}},
+    // double defocus_max = 10;
+    {::_pbi::TcParser::FastF64S1,
+     {81, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.defocus_max_)}},
+    // bool is_cycle = 11;
+    {::_pbi::TcParser::SingularVarintNoZag1<bool, offsetof(ScanTestCfg, _impl_.is_cycle_), 63>(),
+     {88, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.is_cycle_)}},
+    // double cross_x = 12;
+    {::_pbi::TcParser::FastF64S1,
+     {97, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.cross_x_)}},
+    // double cross_y = 13;
+    {::_pbi::TcParser::FastF64S1,
+     {105, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.cross_y_)}},
+    // double z_distance = 14;
+    {::_pbi::TcParser::FastF64S1,
+     {113, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.z_distance_)}},
+    // bool isAutoHeatingScanner = 15;
+    {::_pbi::TcParser::SingularVarintNoZag1<bool, offsetof(ScanTestCfg, _impl_.isautoheatingscanner_), 63>(),
+     {120, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.isautoheatingscanner_)}},
+    // uint32 autoHeatingScannerMinutes = 16;
+    {::_pbi::TcParser::FastV32S2,
+     {384, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.autoheatingscannerminutes_)}},
+    // uint32 autoHeatingScannerSize = 17;
+    {::_pbi::TcParser::FastV32S2,
+     {392, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.autoheatingscannersize_)}},
+    // double autoHeatingScannerSpeed = 18;
+    {::_pbi::TcParser::FastF64S2,
+     {401, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.autoheatingscannerspeed_)}},
+    // double mark_test_start_x = 19;
+    {::_pbi::TcParser::FastF64S2,
+     {409, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.mark_test_start_x_)}},
+    // double mark_test_start_y = 20;
+    {::_pbi::TcParser::FastF64S2,
+     {417, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.mark_test_start_y_)}},
+    // double mark_test_end_x = 21;
+    {::_pbi::TcParser::FastF64S2,
+     {425, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.mark_test_end_x_)}},
+    // double mark_test_end_y = 22;
+    {::_pbi::TcParser::FastF64S2,
+     {433, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.mark_test_end_y_)}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+  }}, {{
+    65535, 65535
+  }}, {{
+    // int32 debugShape = 1;
+    {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.debugshape_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt32)},
+    // int32 shapeSize = 2;
+    {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.shapesize_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt32)},
+    // int32 shapeSizeMin = 3;
+    {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.shapesizemin_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt32)},
+    // int32 shape_size_max = 4;
+    {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.shape_size_max_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt32)},
+    // int32 laser_power = 5;
+    {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.laser_power_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt32)},
+    // int32 laser_power_min = 6;
+    {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.laser_power_min_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt32)},
+    // int32 laser_power_max = 7;
+    {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.laser_power_max_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt32)},
+    // double defocus = 8;
+    {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.defocus_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double defocus_min = 9;
+    {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.defocus_min_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double defocus_max = 10;
+    {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.defocus_max_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // bool is_cycle = 11;
+    {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.is_cycle_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kBool)},
+    // double cross_x = 12;
+    {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.cross_x_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double cross_y = 13;
+    {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.cross_y_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double z_distance = 14;
+    {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.z_distance_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // bool isAutoHeatingScanner = 15;
+    {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.isautoheatingscanner_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kBool)},
+    // uint32 autoHeatingScannerMinutes = 16;
+    {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.autoheatingscannerminutes_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kUInt32)},
+    // uint32 autoHeatingScannerSize = 17;
+    {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.autoheatingscannersize_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kUInt32)},
+    // double autoHeatingScannerSpeed = 18;
+    {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.autoheatingscannerspeed_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double mark_test_start_x = 19;
+    {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.mark_test_start_x_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double mark_test_start_y = 20;
+    {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.mark_test_start_y_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double mark_test_end_x = 21;
+    {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.mark_test_end_x_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double mark_test_end_y = 22;
+    {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.mark_test_end_y_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+  }},
+  // no aux_entries
+  {{
+  }},
+};
+
+::uint8_t* ScanTestCfg::_InternalSerialize(
+    ::uint8_t* target,
+    ::google::protobuf::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:stream.ScanTestCfg)
+  ::uint32_t cached_has_bits = 0;
+  (void)cached_has_bits;
+
+  // int32 debugShape = 1;
+  if (this->_internal_debugshape() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt32ToArrayWithField<1>(
+            stream, this->_internal_debugshape(), target);
+  }
+
+  // int32 shapeSize = 2;
+  if (this->_internal_shapesize() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt32ToArrayWithField<2>(
+            stream, this->_internal_shapesize(), target);
+  }
+
+  // int32 shapeSizeMin = 3;
+  if (this->_internal_shapesizemin() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt32ToArrayWithField<3>(
+            stream, this->_internal_shapesizemin(), target);
+  }
+
+  // int32 shape_size_max = 4;
+  if (this->_internal_shape_size_max() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt32ToArrayWithField<4>(
+            stream, this->_internal_shape_size_max(), target);
+  }
+
+  // int32 laser_power = 5;
+  if (this->_internal_laser_power() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt32ToArrayWithField<5>(
+            stream, this->_internal_laser_power(), target);
+  }
+
+  // int32 laser_power_min = 6;
+  if (this->_internal_laser_power_min() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt32ToArrayWithField<6>(
+            stream, this->_internal_laser_power_min(), target);
+  }
+
+  // int32 laser_power_max = 7;
+  if (this->_internal_laser_power_max() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt32ToArrayWithField<7>(
+            stream, this->_internal_laser_power_max(), target);
+  }
+
+  // double defocus = 8;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_defocus = this->_internal_defocus();
+  ::uint64_t raw_defocus;
+  memcpy(&raw_defocus, &tmp_defocus, sizeof(tmp_defocus));
+  if (raw_defocus != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        8, this->_internal_defocus(), target);
+  }
+
+  // double defocus_min = 9;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_defocus_min = this->_internal_defocus_min();
+  ::uint64_t raw_defocus_min;
+  memcpy(&raw_defocus_min, &tmp_defocus_min, sizeof(tmp_defocus_min));
+  if (raw_defocus_min != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        9, this->_internal_defocus_min(), target);
+  }
+
+  // double defocus_max = 10;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_defocus_max = this->_internal_defocus_max();
+  ::uint64_t raw_defocus_max;
+  memcpy(&raw_defocus_max, &tmp_defocus_max, sizeof(tmp_defocus_max));
+  if (raw_defocus_max != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        10, this->_internal_defocus_max(), target);
+  }
+
+  // bool is_cycle = 11;
+  if (this->_internal_is_cycle() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(
+        11, this->_internal_is_cycle(), target);
+  }
+
+  // double cross_x = 12;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_cross_x = this->_internal_cross_x();
+  ::uint64_t raw_cross_x;
+  memcpy(&raw_cross_x, &tmp_cross_x, sizeof(tmp_cross_x));
+  if (raw_cross_x != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        12, this->_internal_cross_x(), target);
+  }
+
+  // double cross_y = 13;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_cross_y = this->_internal_cross_y();
+  ::uint64_t raw_cross_y;
+  memcpy(&raw_cross_y, &tmp_cross_y, sizeof(tmp_cross_y));
+  if (raw_cross_y != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        13, this->_internal_cross_y(), target);
+  }
+
+  // double z_distance = 14;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_z_distance = this->_internal_z_distance();
+  ::uint64_t raw_z_distance;
+  memcpy(&raw_z_distance, &tmp_z_distance, sizeof(tmp_z_distance));
+  if (raw_z_distance != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        14, this->_internal_z_distance(), target);
+  }
+
+  // bool isAutoHeatingScanner = 15;
+  if (this->_internal_isautoheatingscanner() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(
+        15, this->_internal_isautoheatingscanner(), target);
+  }
+
+  // uint32 autoHeatingScannerMinutes = 16;
+  if (this->_internal_autoheatingscannerminutes() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
+        16, this->_internal_autoheatingscannerminutes(), target);
+  }
+
+  // uint32 autoHeatingScannerSize = 17;
+  if (this->_internal_autoheatingscannersize() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
+        17, this->_internal_autoheatingscannersize(), target);
+  }
+
+  // double autoHeatingScannerSpeed = 18;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_autoheatingscannerspeed = this->_internal_autoheatingscannerspeed();
+  ::uint64_t raw_autoheatingscannerspeed;
+  memcpy(&raw_autoheatingscannerspeed, &tmp_autoheatingscannerspeed, sizeof(tmp_autoheatingscannerspeed));
+  if (raw_autoheatingscannerspeed != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        18, this->_internal_autoheatingscannerspeed(), target);
+  }
+
+  // double mark_test_start_x = 19;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_mark_test_start_x = this->_internal_mark_test_start_x();
+  ::uint64_t raw_mark_test_start_x;
+  memcpy(&raw_mark_test_start_x, &tmp_mark_test_start_x, sizeof(tmp_mark_test_start_x));
+  if (raw_mark_test_start_x != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        19, this->_internal_mark_test_start_x(), target);
+  }
+
+  // double mark_test_start_y = 20;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_mark_test_start_y = this->_internal_mark_test_start_y();
+  ::uint64_t raw_mark_test_start_y;
+  memcpy(&raw_mark_test_start_y, &tmp_mark_test_start_y, sizeof(tmp_mark_test_start_y));
+  if (raw_mark_test_start_y != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        20, this->_internal_mark_test_start_y(), target);
+  }
+
+  // double mark_test_end_x = 21;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_mark_test_end_x = this->_internal_mark_test_end_x();
+  ::uint64_t raw_mark_test_end_x;
+  memcpy(&raw_mark_test_end_x, &tmp_mark_test_end_x, sizeof(tmp_mark_test_end_x));
+  if (raw_mark_test_end_x != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        21, this->_internal_mark_test_end_x(), target);
+  }
+
+  // double mark_test_end_y = 22;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_mark_test_end_y = this->_internal_mark_test_end_y();
+  ::uint64_t raw_mark_test_end_y;
+  memcpy(&raw_mark_test_end_y, &tmp_mark_test_end_y, sizeof(tmp_mark_test_end_y));
+  if (raw_mark_test_end_y != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        22, this->_internal_mark_test_end_y(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target =
+        ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
+            _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:stream.ScanTestCfg)
+  return target;
+}
+
+::size_t ScanTestCfg::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:stream.ScanTestCfg)
+  ::size_t total_size = 0;
+
+  ::uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // int32 debugShape = 1;
+  if (this->_internal_debugshape() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
+        this->_internal_debugshape());
+  }
+
+  // int32 shapeSize = 2;
+  if (this->_internal_shapesize() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
+        this->_internal_shapesize());
+  }
+
+  // int32 shapeSizeMin = 3;
+  if (this->_internal_shapesizemin() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
+        this->_internal_shapesizemin());
+  }
+
+  // int32 shape_size_max = 4;
+  if (this->_internal_shape_size_max() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
+        this->_internal_shape_size_max());
+  }
+
+  // int32 laser_power = 5;
+  if (this->_internal_laser_power() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
+        this->_internal_laser_power());
+  }
+
+  // int32 laser_power_min = 6;
+  if (this->_internal_laser_power_min() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
+        this->_internal_laser_power_min());
+  }
+
+  // double defocus = 8;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_defocus = this->_internal_defocus();
+  ::uint64_t raw_defocus;
+  memcpy(&raw_defocus, &tmp_defocus, sizeof(tmp_defocus));
+  if (raw_defocus != 0) {
+    total_size += 9;
+  }
+
+  // double defocus_min = 9;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_defocus_min = this->_internal_defocus_min();
+  ::uint64_t raw_defocus_min;
+  memcpy(&raw_defocus_min, &tmp_defocus_min, sizeof(tmp_defocus_min));
+  if (raw_defocus_min != 0) {
+    total_size += 9;
+  }
+
+  // double defocus_max = 10;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_defocus_max = this->_internal_defocus_max();
+  ::uint64_t raw_defocus_max;
+  memcpy(&raw_defocus_max, &tmp_defocus_max, sizeof(tmp_defocus_max));
+  if (raw_defocus_max != 0) {
+    total_size += 9;
+  }
+
+  // int32 laser_power_max = 7;
+  if (this->_internal_laser_power_max() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
+        this->_internal_laser_power_max());
+  }
+
+  // bool is_cycle = 11;
+  if (this->_internal_is_cycle() != 0) {
+    total_size += 2;
+  }
+
+  // bool isAutoHeatingScanner = 15;
+  if (this->_internal_isautoheatingscanner() != 0) {
+    total_size += 2;
+  }
+
+  // double cross_x = 12;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_cross_x = this->_internal_cross_x();
+  ::uint64_t raw_cross_x;
+  memcpy(&raw_cross_x, &tmp_cross_x, sizeof(tmp_cross_x));
+  if (raw_cross_x != 0) {
+    total_size += 9;
+  }
+
+  // double cross_y = 13;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_cross_y = this->_internal_cross_y();
+  ::uint64_t raw_cross_y;
+  memcpy(&raw_cross_y, &tmp_cross_y, sizeof(tmp_cross_y));
+  if (raw_cross_y != 0) {
+    total_size += 9;
+  }
+
+  // double z_distance = 14;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_z_distance = this->_internal_z_distance();
+  ::uint64_t raw_z_distance;
+  memcpy(&raw_z_distance, &tmp_z_distance, sizeof(tmp_z_distance));
+  if (raw_z_distance != 0) {
+    total_size += 9;
+  }
+
+  // uint32 autoHeatingScannerMinutes = 16;
+  if (this->_internal_autoheatingscannerminutes() != 0) {
+    total_size += 2 + ::_pbi::WireFormatLite::UInt32Size(
+                                    this->_internal_autoheatingscannerminutes());
+  }
+
+  // uint32 autoHeatingScannerSize = 17;
+  if (this->_internal_autoheatingscannersize() != 0) {
+    total_size += 2 + ::_pbi::WireFormatLite::UInt32Size(
+                                    this->_internal_autoheatingscannersize());
+  }
+
+  // double autoHeatingScannerSpeed = 18;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_autoheatingscannerspeed = this->_internal_autoheatingscannerspeed();
+  ::uint64_t raw_autoheatingscannerspeed;
+  memcpy(&raw_autoheatingscannerspeed, &tmp_autoheatingscannerspeed, sizeof(tmp_autoheatingscannerspeed));
+  if (raw_autoheatingscannerspeed != 0) {
+    total_size += 10;
+  }
+
+  // double mark_test_start_x = 19;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_mark_test_start_x = this->_internal_mark_test_start_x();
+  ::uint64_t raw_mark_test_start_x;
+  memcpy(&raw_mark_test_start_x, &tmp_mark_test_start_x, sizeof(tmp_mark_test_start_x));
+  if (raw_mark_test_start_x != 0) {
+    total_size += 10;
+  }
+
+  // double mark_test_start_y = 20;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_mark_test_start_y = this->_internal_mark_test_start_y();
+  ::uint64_t raw_mark_test_start_y;
+  memcpy(&raw_mark_test_start_y, &tmp_mark_test_start_y, sizeof(tmp_mark_test_start_y));
+  if (raw_mark_test_start_y != 0) {
+    total_size += 10;
+  }
+
+  // double mark_test_end_x = 21;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_mark_test_end_x = this->_internal_mark_test_end_x();
+  ::uint64_t raw_mark_test_end_x;
+  memcpy(&raw_mark_test_end_x, &tmp_mark_test_end_x, sizeof(tmp_mark_test_end_x));
+  if (raw_mark_test_end_x != 0) {
+    total_size += 10;
+  }
+
+  // double mark_test_end_y = 22;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_mark_test_end_y = this->_internal_mark_test_end_y();
+  ::uint64_t raw_mark_test_end_y;
+  memcpy(&raw_mark_test_end_y, &tmp_mark_test_end_y, sizeof(tmp_mark_test_end_y));
+  if (raw_mark_test_end_y != 0) {
+    total_size += 10;
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::google::protobuf::Message::ClassData ScanTestCfg::_class_data_ = {
+    ::google::protobuf::Message::CopyWithSourceCheck,
+    ScanTestCfg::MergeImpl
+};
+const ::google::protobuf::Message::ClassData*ScanTestCfg::GetClassData() const { return &_class_data_; }
+
+
+void ScanTestCfg::MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg) {
+  auto* const _this = static_cast<ScanTestCfg*>(&to_msg);
+  auto& from = static_cast<const ScanTestCfg&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:stream.ScanTestCfg)
+  ABSL_DCHECK_NE(&from, _this);
+  ::uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_debugshape() != 0) {
+    _this->_internal_set_debugshape(from._internal_debugshape());
+  }
+  if (from._internal_shapesize() != 0) {
+    _this->_internal_set_shapesize(from._internal_shapesize());
+  }
+  if (from._internal_shapesizemin() != 0) {
+    _this->_internal_set_shapesizemin(from._internal_shapesizemin());
+  }
+  if (from._internal_shape_size_max() != 0) {
+    _this->_internal_set_shape_size_max(from._internal_shape_size_max());
+  }
+  if (from._internal_laser_power() != 0) {
+    _this->_internal_set_laser_power(from._internal_laser_power());
+  }
+  if (from._internal_laser_power_min() != 0) {
+    _this->_internal_set_laser_power_min(from._internal_laser_power_min());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_defocus = from._internal_defocus();
+  ::uint64_t raw_defocus;
+  memcpy(&raw_defocus, &tmp_defocus, sizeof(tmp_defocus));
+  if (raw_defocus != 0) {
+    _this->_internal_set_defocus(from._internal_defocus());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_defocus_min = from._internal_defocus_min();
+  ::uint64_t raw_defocus_min;
+  memcpy(&raw_defocus_min, &tmp_defocus_min, sizeof(tmp_defocus_min));
+  if (raw_defocus_min != 0) {
+    _this->_internal_set_defocus_min(from._internal_defocus_min());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_defocus_max = from._internal_defocus_max();
+  ::uint64_t raw_defocus_max;
+  memcpy(&raw_defocus_max, &tmp_defocus_max, sizeof(tmp_defocus_max));
+  if (raw_defocus_max != 0) {
+    _this->_internal_set_defocus_max(from._internal_defocus_max());
+  }
+  if (from._internal_laser_power_max() != 0) {
+    _this->_internal_set_laser_power_max(from._internal_laser_power_max());
+  }
+  if (from._internal_is_cycle() != 0) {
+    _this->_internal_set_is_cycle(from._internal_is_cycle());
+  }
+  if (from._internal_isautoheatingscanner() != 0) {
+    _this->_internal_set_isautoheatingscanner(from._internal_isautoheatingscanner());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_cross_x = from._internal_cross_x();
+  ::uint64_t raw_cross_x;
+  memcpy(&raw_cross_x, &tmp_cross_x, sizeof(tmp_cross_x));
+  if (raw_cross_x != 0) {
+    _this->_internal_set_cross_x(from._internal_cross_x());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_cross_y = from._internal_cross_y();
+  ::uint64_t raw_cross_y;
+  memcpy(&raw_cross_y, &tmp_cross_y, sizeof(tmp_cross_y));
+  if (raw_cross_y != 0) {
+    _this->_internal_set_cross_y(from._internal_cross_y());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_z_distance = from._internal_z_distance();
+  ::uint64_t raw_z_distance;
+  memcpy(&raw_z_distance, &tmp_z_distance, sizeof(tmp_z_distance));
+  if (raw_z_distance != 0) {
+    _this->_internal_set_z_distance(from._internal_z_distance());
+  }
+  if (from._internal_autoheatingscannerminutes() != 0) {
+    _this->_internal_set_autoheatingscannerminutes(from._internal_autoheatingscannerminutes());
+  }
+  if (from._internal_autoheatingscannersize() != 0) {
+    _this->_internal_set_autoheatingscannersize(from._internal_autoheatingscannersize());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_autoheatingscannerspeed = from._internal_autoheatingscannerspeed();
+  ::uint64_t raw_autoheatingscannerspeed;
+  memcpy(&raw_autoheatingscannerspeed, &tmp_autoheatingscannerspeed, sizeof(tmp_autoheatingscannerspeed));
+  if (raw_autoheatingscannerspeed != 0) {
+    _this->_internal_set_autoheatingscannerspeed(from._internal_autoheatingscannerspeed());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_mark_test_start_x = from._internal_mark_test_start_x();
+  ::uint64_t raw_mark_test_start_x;
+  memcpy(&raw_mark_test_start_x, &tmp_mark_test_start_x, sizeof(tmp_mark_test_start_x));
+  if (raw_mark_test_start_x != 0) {
+    _this->_internal_set_mark_test_start_x(from._internal_mark_test_start_x());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_mark_test_start_y = from._internal_mark_test_start_y();
+  ::uint64_t raw_mark_test_start_y;
+  memcpy(&raw_mark_test_start_y, &tmp_mark_test_start_y, sizeof(tmp_mark_test_start_y));
+  if (raw_mark_test_start_y != 0) {
+    _this->_internal_set_mark_test_start_y(from._internal_mark_test_start_y());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_mark_test_end_x = from._internal_mark_test_end_x();
+  ::uint64_t raw_mark_test_end_x;
+  memcpy(&raw_mark_test_end_x, &tmp_mark_test_end_x, sizeof(tmp_mark_test_end_x));
+  if (raw_mark_test_end_x != 0) {
+    _this->_internal_set_mark_test_end_x(from._internal_mark_test_end_x());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_mark_test_end_y = from._internal_mark_test_end_y();
+  ::uint64_t raw_mark_test_end_y;
+  memcpy(&raw_mark_test_end_y, &tmp_mark_test_end_y, sizeof(tmp_mark_test_end_y));
+  if (raw_mark_test_end_y != 0) {
+    _this->_internal_set_mark_test_end_y(from._internal_mark_test_end_y());
+  }
+  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ScanTestCfg::CopyFrom(const ScanTestCfg& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:stream.ScanTestCfg)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+PROTOBUF_NOINLINE bool ScanTestCfg::IsInitialized() const {
+  return true;
+}
+
+void ScanTestCfg::InternalSwap(ScanTestCfg* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::google::protobuf::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.mark_test_end_y_)
+      + sizeof(ScanTestCfg::_impl_.mark_test_end_y_)
+      - PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.debugshape_)>(
+          reinterpret_cast<char*>(&_impl_.debugshape_),
+          reinterpret_cast<char*>(&other->_impl_.debugshape_));
+}
+
+::google::protobuf::Metadata ScanTestCfg::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_stream_2eproto_getter, &descriptor_table_stream_2eproto_once,
+      file_level_metadata_stream_2eproto[17]);
+}
+// ===================================================================
+
+class SkyWritingCfg::_Internal {
+ public:
+};
+
+SkyWritingCfg::SkyWritingCfg(::google::protobuf::Arena* arena)
+    : ::google::protobuf::Message(arena) {
+  SharedCtor(arena);
+  // @@protoc_insertion_point(arena_constructor:stream.SkyWritingCfg)
+}
+SkyWritingCfg::SkyWritingCfg(const SkyWritingCfg& from)
+    : ::google::protobuf::Message(), _impl_(from._impl_) {
+  _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
+      from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:stream.SkyWritingCfg)
+}
+inline void SkyWritingCfg::SharedCtor(::_pb::Arena* arena) {
+  (void)arena;
+  new (&_impl_) Impl_{
+      decltype(_impl_.timelag_){0},
+      decltype(_impl_.timelagmin_){0},
+      decltype(_impl_.timelagmax_){0},
+      decltype(_impl_.isenable_){false},
+      decltype(_impl_.nprev_){0u},
+      decltype(_impl_.laseronshift_){::int64_t{0}},
+      decltype(_impl_.laseronshiftmin_){::int64_t{0}},
+      decltype(_impl_.laseronshiftmax_){::int64_t{0}},
+      decltype(_impl_.nprevmin_){0u},
+      decltype(_impl_.nprevmax_){0u},
+      decltype(_impl_.npost_){0u},
+      decltype(_impl_.npostmin_){0u},
+      decltype(_impl_.npostmax_){0u},
+      decltype(_impl_.mode_){0},
+      decltype(_impl_.limite_){0},
+      decltype(_impl_.limitemin_){0},
+      decltype(_impl_.limitemax_){0},
+      /*decltype(_impl_._cached_size_)*/ {},
+  };
+}
+SkyWritingCfg::~SkyWritingCfg() {
+  // @@protoc_insertion_point(destructor:stream.SkyWritingCfg)
+  _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
+  SharedDtor();
+}
+inline void SkyWritingCfg::SharedDtor() {
+  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
+}
+void SkyWritingCfg::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+PROTOBUF_NOINLINE void SkyWritingCfg::Clear() {
+// @@protoc_insertion_point(message_clear_start:stream.SkyWritingCfg)
+  ::uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  ::memset(&_impl_.timelag_, 0, static_cast<::size_t>(
+      reinterpret_cast<char*>(&_impl_.limitemax_) -
+      reinterpret_cast<char*>(&_impl_.timelag_)) + sizeof(_impl_.limitemax_));
+  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
+}
+
+const char* SkyWritingCfg::_InternalParse(
+    const char* ptr, ::_pbi::ParseContext* ctx) {
+  ptr = ::_pbi::TcParser::ParseLoop(this, ptr, ctx, &_table_.header);
+  return ptr;
+}
+
+
+PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
+const ::_pbi::TcParseTable<5, 17, 0, 0, 2> SkyWritingCfg::_table_ = {
+  {
+    0,  // no _has_bits_
+    0, // no _extensions_
+    17, 248,  // max_field_number, fast_idx_mask
+    offsetof(decltype(_table_), field_lookup_table),
+    4294836224,  // skipmap
+    offsetof(decltype(_table_), field_entries),
+    17,  // num_field_entries
+    0,  // num_aux_entries
+    offsetof(decltype(_table_), field_names),  // no aux_entries
+    &_SkyWritingCfg_default_instance_._instance,
+    ::_pbi::TcParser::GenericFallback,  // fallback
+  }, {{
+    {::_pbi::TcParser::MiniParse, {}},
+    // bool isEnable = 1;
+    {::_pbi::TcParser::SingularVarintNoZag1<bool, offsetof(SkyWritingCfg, _impl_.isenable_), 63>(),
+     {8, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.isenable_)}},
+    // double timelag = 2;
+    {::_pbi::TcParser::FastF64S1,
+     {17, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.timelag_)}},
+    // double timelagMin = 3;
+    {::_pbi::TcParser::FastF64S1,
+     {25, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.timelagmin_)}},
+    // double timelagMax = 4;
+    {::_pbi::TcParser::FastF64S1,
+     {33, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.timelagmax_)}},
+    // int64 laserOnShift = 5;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(SkyWritingCfg, _impl_.laseronshift_), 63>(),
+     {40, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.laseronshift_)}},
+    // int64 laserOnShiftMin = 6;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(SkyWritingCfg, _impl_.laseronshiftmin_), 63>(),
+     {48, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.laseronshiftmin_)}},
+    // int64 laserOnShiftMax = 7;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(SkyWritingCfg, _impl_.laseronshiftmax_), 63>(),
+     {56, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.laseronshiftmax_)}},
+    // uint32 nprev = 8;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(SkyWritingCfg, _impl_.nprev_), 63>(),
+     {64, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.nprev_)}},
+    // uint32 nprevMin = 9;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(SkyWritingCfg, _impl_.nprevmin_), 63>(),
+     {72, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.nprevmin_)}},
+    // uint32 nprevMax = 10;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(SkyWritingCfg, _impl_.nprevmax_), 63>(),
+     {80, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.nprevmax_)}},
+    // uint32 npost = 11;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(SkyWritingCfg, _impl_.npost_), 63>(),
+     {88, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.npost_)}},
+    // uint32 npostMin = 12;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(SkyWritingCfg, _impl_.npostmin_), 63>(),
+     {96, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.npostmin_)}},
+    // uint32 npostMax = 13;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(SkyWritingCfg, _impl_.npostmax_), 63>(),
+     {104, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.npostmax_)}},
+    // int32 mode = 14;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(SkyWritingCfg, _impl_.mode_), 63>(),
+     {112, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.mode_)}},
+    // double limite = 15;
+    {::_pbi::TcParser::FastF64S1,
+     {121, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.limite_)}},
+    // double limiteMin = 16;
+    {::_pbi::TcParser::FastF64S2,
+     {385, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.limitemin_)}},
+    // double limiteMax = 17;
+    {::_pbi::TcParser::FastF64S2,
+     {393, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.limitemax_)}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+  }}, {{
+    65535, 65535
+  }}, {{
+    // bool isEnable = 1;
+    {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.isenable_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kBool)},
+    // double timelag = 2;
+    {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.timelag_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double timelagMin = 3;
+    {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.timelagmin_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double timelagMax = 4;
+    {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.timelagmax_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // int64 laserOnShift = 5;
+    {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.laseronshift_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt64)},
+    // int64 laserOnShiftMin = 6;
+    {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.laseronshiftmin_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt64)},
+    // int64 laserOnShiftMax = 7;
+    {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.laseronshiftmax_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt64)},
+    // uint32 nprev = 8;
+    {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.nprev_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kUInt32)},
+    // uint32 nprevMin = 9;
+    {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.nprevmin_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kUInt32)},
+    // uint32 nprevMax = 10;
+    {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.nprevmax_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kUInt32)},
+    // uint32 npost = 11;
+    {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.npost_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kUInt32)},
+    // uint32 npostMin = 12;
+    {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.npostmin_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kUInt32)},
+    // uint32 npostMax = 13;
+    {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.npostmax_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kUInt32)},
+    // int32 mode = 14;
+    {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.mode_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt32)},
+    // double limite = 15;
+    {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.limite_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double limiteMin = 16;
+    {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.limitemin_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double limiteMax = 17;
+    {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.limitemax_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+  }},
+  // no aux_entries
+  {{
+  }},
+};
+
+::uint8_t* SkyWritingCfg::_InternalSerialize(
+    ::uint8_t* target,
+    ::google::protobuf::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:stream.SkyWritingCfg)
+  ::uint32_t cached_has_bits = 0;
+  (void)cached_has_bits;
+
+  // bool isEnable = 1;
+  if (this->_internal_isenable() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(
+        1, this->_internal_isenable(), target);
+  }
+
+  // double timelag = 2;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_timelag = this->_internal_timelag();
+  ::uint64_t raw_timelag;
+  memcpy(&raw_timelag, &tmp_timelag, sizeof(tmp_timelag));
+  if (raw_timelag != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        2, this->_internal_timelag(), target);
+  }
+
+  // double timelagMin = 3;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_timelagmin = this->_internal_timelagmin();
+  ::uint64_t raw_timelagmin;
+  memcpy(&raw_timelagmin, &tmp_timelagmin, sizeof(tmp_timelagmin));
+  if (raw_timelagmin != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        3, this->_internal_timelagmin(), target);
+  }
+
+  // double timelagMax = 4;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_timelagmax = this->_internal_timelagmax();
+  ::uint64_t raw_timelagmax;
+  memcpy(&raw_timelagmax, &tmp_timelagmax, sizeof(tmp_timelagmax));
+  if (raw_timelagmax != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        4, this->_internal_timelagmax(), target);
+  }
+
+  // int64 laserOnShift = 5;
+  if (this->_internal_laseronshift() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt64ToArrayWithField<5>(
+            stream, this->_internal_laseronshift(), target);
+  }
+
+  // int64 laserOnShiftMin = 6;
+  if (this->_internal_laseronshiftmin() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt64ToArrayWithField<6>(
+            stream, this->_internal_laseronshiftmin(), target);
+  }
+
+  // int64 laserOnShiftMax = 7;
+  if (this->_internal_laseronshiftmax() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt64ToArrayWithField<7>(
+            stream, this->_internal_laseronshiftmax(), target);
+  }
+
+  // uint32 nprev = 8;
+  if (this->_internal_nprev() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
+        8, this->_internal_nprev(), target);
+  }
+
+  // uint32 nprevMin = 9;
+  if (this->_internal_nprevmin() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
+        9, this->_internal_nprevmin(), target);
+  }
+
+  // uint32 nprevMax = 10;
+  if (this->_internal_nprevmax() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
+        10, this->_internal_nprevmax(), target);
+  }
+
+  // uint32 npost = 11;
+  if (this->_internal_npost() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
+        11, this->_internal_npost(), target);
+  }
+
+  // uint32 npostMin = 12;
+  if (this->_internal_npostmin() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
+        12, this->_internal_npostmin(), target);
+  }
+
+  // uint32 npostMax = 13;
+  if (this->_internal_npostmax() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
+        13, this->_internal_npostmax(), target);
+  }
+
+  // int32 mode = 14;
+  if (this->_internal_mode() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt32ToArrayWithField<14>(
+            stream, this->_internal_mode(), target);
+  }
+
+  // double limite = 15;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_limite = this->_internal_limite();
+  ::uint64_t raw_limite;
+  memcpy(&raw_limite, &tmp_limite, sizeof(tmp_limite));
+  if (raw_limite != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        15, this->_internal_limite(), target);
+  }
+
+  // double limiteMin = 16;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_limitemin = this->_internal_limitemin();
+  ::uint64_t raw_limitemin;
+  memcpy(&raw_limitemin, &tmp_limitemin, sizeof(tmp_limitemin));
+  if (raw_limitemin != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        16, this->_internal_limitemin(), target);
+  }
+
+  // double limiteMax = 17;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_limitemax = this->_internal_limitemax();
+  ::uint64_t raw_limitemax;
+  memcpy(&raw_limitemax, &tmp_limitemax, sizeof(tmp_limitemax));
+  if (raw_limitemax != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        17, this->_internal_limitemax(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target =
+        ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
+            _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:stream.SkyWritingCfg)
+  return target;
+}
+
+::size_t SkyWritingCfg::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:stream.SkyWritingCfg)
+  ::size_t total_size = 0;
+
+  ::uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // double timelag = 2;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_timelag = this->_internal_timelag();
+  ::uint64_t raw_timelag;
+  memcpy(&raw_timelag, &tmp_timelag, sizeof(tmp_timelag));
+  if (raw_timelag != 0) {
+    total_size += 9;
+  }
+
+  // double timelagMin = 3;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_timelagmin = this->_internal_timelagmin();
+  ::uint64_t raw_timelagmin;
+  memcpy(&raw_timelagmin, &tmp_timelagmin, sizeof(tmp_timelagmin));
+  if (raw_timelagmin != 0) {
+    total_size += 9;
+  }
+
+  // double timelagMax = 4;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_timelagmax = this->_internal_timelagmax();
+  ::uint64_t raw_timelagmax;
+  memcpy(&raw_timelagmax, &tmp_timelagmax, sizeof(tmp_timelagmax));
+  if (raw_timelagmax != 0) {
+    total_size += 9;
+  }
+
+  // bool isEnable = 1;
+  if (this->_internal_isenable() != 0) {
+    total_size += 2;
+  }
+
+  // uint32 nprev = 8;
+  if (this->_internal_nprev() != 0) {
+    total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
+        this->_internal_nprev());
+  }
+
+  // int64 laserOnShift = 5;
+  if (this->_internal_laseronshift() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(
+        this->_internal_laseronshift());
+  }
+
+  // int64 laserOnShiftMin = 6;
+  if (this->_internal_laseronshiftmin() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(
+        this->_internal_laseronshiftmin());
+  }
+
+  // int64 laserOnShiftMax = 7;
+  if (this->_internal_laseronshiftmax() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(
+        this->_internal_laseronshiftmax());
+  }
+
+  // uint32 nprevMin = 9;
+  if (this->_internal_nprevmin() != 0) {
+    total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
+        this->_internal_nprevmin());
+  }
+
+  // uint32 nprevMax = 10;
+  if (this->_internal_nprevmax() != 0) {
+    total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
+        this->_internal_nprevmax());
+  }
+
+  // uint32 npost = 11;
+  if (this->_internal_npost() != 0) {
+    total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
+        this->_internal_npost());
+  }
+
+  // uint32 npostMin = 12;
+  if (this->_internal_npostmin() != 0) {
+    total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
+        this->_internal_npostmin());
+  }
+
+  // uint32 npostMax = 13;
+  if (this->_internal_npostmax() != 0) {
+    total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
+        this->_internal_npostmax());
+  }
+
+  // int32 mode = 14;
+  if (this->_internal_mode() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
+        this->_internal_mode());
+  }
+
+  // double limite = 15;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_limite = this->_internal_limite();
+  ::uint64_t raw_limite;
+  memcpy(&raw_limite, &tmp_limite, sizeof(tmp_limite));
+  if (raw_limite != 0) {
+    total_size += 9;
+  }
+
+  // double limiteMin = 16;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_limitemin = this->_internal_limitemin();
+  ::uint64_t raw_limitemin;
+  memcpy(&raw_limitemin, &tmp_limitemin, sizeof(tmp_limitemin));
+  if (raw_limitemin != 0) {
+    total_size += 10;
+  }
+
+  // double limiteMax = 17;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_limitemax = this->_internal_limitemax();
+  ::uint64_t raw_limitemax;
+  memcpy(&raw_limitemax, &tmp_limitemax, sizeof(tmp_limitemax));
+  if (raw_limitemax != 0) {
+    total_size += 10;
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::google::protobuf::Message::ClassData SkyWritingCfg::_class_data_ = {
+    ::google::protobuf::Message::CopyWithSourceCheck,
+    SkyWritingCfg::MergeImpl
+};
+const ::google::protobuf::Message::ClassData*SkyWritingCfg::GetClassData() const { return &_class_data_; }
+
+
+void SkyWritingCfg::MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg) {
+  auto* const _this = static_cast<SkyWritingCfg*>(&to_msg);
+  auto& from = static_cast<const SkyWritingCfg&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:stream.SkyWritingCfg)
+  ABSL_DCHECK_NE(&from, _this);
+  ::uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_timelag = from._internal_timelag();
+  ::uint64_t raw_timelag;
+  memcpy(&raw_timelag, &tmp_timelag, sizeof(tmp_timelag));
+  if (raw_timelag != 0) {
+    _this->_internal_set_timelag(from._internal_timelag());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_timelagmin = from._internal_timelagmin();
+  ::uint64_t raw_timelagmin;
+  memcpy(&raw_timelagmin, &tmp_timelagmin, sizeof(tmp_timelagmin));
+  if (raw_timelagmin != 0) {
+    _this->_internal_set_timelagmin(from._internal_timelagmin());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_timelagmax = from._internal_timelagmax();
+  ::uint64_t raw_timelagmax;
+  memcpy(&raw_timelagmax, &tmp_timelagmax, sizeof(tmp_timelagmax));
+  if (raw_timelagmax != 0) {
+    _this->_internal_set_timelagmax(from._internal_timelagmax());
+  }
+  if (from._internal_isenable() != 0) {
+    _this->_internal_set_isenable(from._internal_isenable());
+  }
+  if (from._internal_nprev() != 0) {
+    _this->_internal_set_nprev(from._internal_nprev());
+  }
+  if (from._internal_laseronshift() != 0) {
+    _this->_internal_set_laseronshift(from._internal_laseronshift());
+  }
+  if (from._internal_laseronshiftmin() != 0) {
+    _this->_internal_set_laseronshiftmin(from._internal_laseronshiftmin());
+  }
+  if (from._internal_laseronshiftmax() != 0) {
+    _this->_internal_set_laseronshiftmax(from._internal_laseronshiftmax());
+  }
+  if (from._internal_nprevmin() != 0) {
+    _this->_internal_set_nprevmin(from._internal_nprevmin());
+  }
+  if (from._internal_nprevmax() != 0) {
+    _this->_internal_set_nprevmax(from._internal_nprevmax());
+  }
+  if (from._internal_npost() != 0) {
+    _this->_internal_set_npost(from._internal_npost());
+  }
+  if (from._internal_npostmin() != 0) {
+    _this->_internal_set_npostmin(from._internal_npostmin());
+  }
+  if (from._internal_npostmax() != 0) {
+    _this->_internal_set_npostmax(from._internal_npostmax());
+  }
+  if (from._internal_mode() != 0) {
+    _this->_internal_set_mode(from._internal_mode());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_limite = from._internal_limite();
+  ::uint64_t raw_limite;
+  memcpy(&raw_limite, &tmp_limite, sizeof(tmp_limite));
+  if (raw_limite != 0) {
+    _this->_internal_set_limite(from._internal_limite());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_limitemin = from._internal_limitemin();
+  ::uint64_t raw_limitemin;
+  memcpy(&raw_limitemin, &tmp_limitemin, sizeof(tmp_limitemin));
+  if (raw_limitemin != 0) {
+    _this->_internal_set_limitemin(from._internal_limitemin());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_limitemax = from._internal_limitemax();
+  ::uint64_t raw_limitemax;
+  memcpy(&raw_limitemax, &tmp_limitemax, sizeof(tmp_limitemax));
+  if (raw_limitemax != 0) {
+    _this->_internal_set_limitemax(from._internal_limitemax());
+  }
+  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SkyWritingCfg::CopyFrom(const SkyWritingCfg& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:stream.SkyWritingCfg)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+PROTOBUF_NOINLINE bool SkyWritingCfg::IsInitialized() const {
+  return true;
+}
+
+void SkyWritingCfg::InternalSwap(SkyWritingCfg* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::google::protobuf::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.limitemax_)
+      + sizeof(SkyWritingCfg::_impl_.limitemax_)
+      - PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.timelag_)>(
+          reinterpret_cast<char*>(&_impl_.timelag_),
+          reinterpret_cast<char*>(&other->_impl_.timelag_));
+}
+
+::google::protobuf::Metadata SkyWritingCfg::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_stream_2eproto_getter, &descriptor_table_stream_2eproto_once,
+      file_level_metadata_stream_2eproto[18]);
+}
+// ===================================================================
+
+class PowerCompensate::_Internal {
+ public:
+};
+
+PowerCompensate::PowerCompensate(::google::protobuf::Arena* arena)
+    : ::google::protobuf::Message(arena) {
+  SharedCtor(arena);
+  // @@protoc_insertion_point(arena_constructor:stream.PowerCompensate)
+}
+PowerCompensate::PowerCompensate(const PowerCompensate& from)
+    : ::google::protobuf::Message(), _impl_(from._impl_) {
+  _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
+      from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:stream.PowerCompensate)
+}
+inline void PowerCompensate::SharedCtor(::_pb::Arena* arena) {
+  (void)arena;
+  new (&_impl_) Impl_{
+      decltype(_impl_.cno_){0},
+      decltype(_impl_.percent_){0},
+      decltype(_impl_.value_){0},
+      decltype(_impl_.value_min_){0},
+      decltype(_impl_.value_max_){0},
+      /*decltype(_impl_._cached_size_)*/ {},
+  };
+}
+PowerCompensate::~PowerCompensate() {
+  // @@protoc_insertion_point(destructor:stream.PowerCompensate)
+  _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
+  SharedDtor();
+}
+inline void PowerCompensate::SharedDtor() {
+  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
+}
+void PowerCompensate::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+PROTOBUF_NOINLINE void PowerCompensate::Clear() {
+// @@protoc_insertion_point(message_clear_start:stream.PowerCompensate)
+  ::uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  ::memset(&_impl_.cno_, 0, static_cast<::size_t>(
+      reinterpret_cast<char*>(&_impl_.value_max_) -
+      reinterpret_cast<char*>(&_impl_.cno_)) + sizeof(_impl_.value_max_));
+  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
+}
+
+const char* PowerCompensate::_InternalParse(
+    const char* ptr, ::_pbi::ParseContext* ctx) {
+  ptr = ::_pbi::TcParser::ParseLoop(this, ptr, ctx, &_table_.header);
+  return ptr;
+}
+
+
+PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
+const ::_pbi::TcParseTable<3, 5, 0, 0, 2> PowerCompensate::_table_ = {
+  {
+    0,  // no _has_bits_
+    0, // no _extensions_
+    5, 56,  // max_field_number, fast_idx_mask
+    offsetof(decltype(_table_), field_lookup_table),
+    4294967264,  // skipmap
+    offsetof(decltype(_table_), field_entries),
+    5,  // num_field_entries
+    0,  // num_aux_entries
+    offsetof(decltype(_table_), field_names),  // no aux_entries
+    &_PowerCompensate_default_instance_._instance,
+    ::_pbi::TcParser::GenericFallback,  // fallback
+  }, {{
+    {::_pbi::TcParser::MiniParse, {}},
+    // int32 cno = 1;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(PowerCompensate, _impl_.cno_), 63>(),
+     {8, 63, 0, PROTOBUF_FIELD_OFFSET(PowerCompensate, _impl_.cno_)}},
+    // int32 percent = 2;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(PowerCompensate, _impl_.percent_), 63>(),
+     {16, 63, 0, PROTOBUF_FIELD_OFFSET(PowerCompensate, _impl_.percent_)}},
+    // float value = 3;
+    {::_pbi::TcParser::FastF32S1,
+     {29, 63, 0, PROTOBUF_FIELD_OFFSET(PowerCompensate, _impl_.value_)}},
+    // float value_min = 4;
+    {::_pbi::TcParser::FastF32S1,
+     {37, 63, 0, PROTOBUF_FIELD_OFFSET(PowerCompensate, _impl_.value_min_)}},
+    // float value_max = 5;
+    {::_pbi::TcParser::FastF32S1,
+     {45, 63, 0, PROTOBUF_FIELD_OFFSET(PowerCompensate, _impl_.value_max_)}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+  }}, {{
+    65535, 65535
+  }}, {{
+    // int32 cno = 1;
+    {PROTOBUF_FIELD_OFFSET(PowerCompensate, _impl_.cno_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt32)},
+    // int32 percent = 2;
+    {PROTOBUF_FIELD_OFFSET(PowerCompensate, _impl_.percent_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt32)},
+    // float value = 3;
+    {PROTOBUF_FIELD_OFFSET(PowerCompensate, _impl_.value_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kFloat)},
+    // float value_min = 4;
+    {PROTOBUF_FIELD_OFFSET(PowerCompensate, _impl_.value_min_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kFloat)},
+    // float value_max = 5;
+    {PROTOBUF_FIELD_OFFSET(PowerCompensate, _impl_.value_max_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kFloat)},
+  }},
+  // no aux_entries
+  {{
+  }},
+};
+
+::uint8_t* PowerCompensate::_InternalSerialize(
+    ::uint8_t* target,
+    ::google::protobuf::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:stream.PowerCompensate)
+  ::uint32_t cached_has_bits = 0;
+  (void)cached_has_bits;
+
+  // int32 cno = 1;
+  if (this->_internal_cno() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt32ToArrayWithField<1>(
+            stream, this->_internal_cno(), target);
+  }
+
+  // int32 percent = 2;
+  if (this->_internal_percent() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt32ToArrayWithField<2>(
+            stream, this->_internal_percent(), target);
+  }
+
+  // float value = 3;
+  static_assert(sizeof(::uint32_t) == sizeof(float),
+                "Code assumes ::uint32_t and float are the same size.");
+  float tmp_value = this->_internal_value();
+  ::uint32_t raw_value;
+  memcpy(&raw_value, &tmp_value, sizeof(tmp_value));
+  if (raw_value != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteFloatToArray(
+        3, this->_internal_value(), target);
+  }
+
+  // float value_min = 4;
+  static_assert(sizeof(::uint32_t) == sizeof(float),
+                "Code assumes ::uint32_t and float are the same size.");
+  float tmp_value_min = this->_internal_value_min();
+  ::uint32_t raw_value_min;
+  memcpy(&raw_value_min, &tmp_value_min, sizeof(tmp_value_min));
+  if (raw_value_min != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteFloatToArray(
+        4, this->_internal_value_min(), target);
+  }
+
+  // float value_max = 5;
+  static_assert(sizeof(::uint32_t) == sizeof(float),
+                "Code assumes ::uint32_t and float are the same size.");
+  float tmp_value_max = this->_internal_value_max();
+  ::uint32_t raw_value_max;
+  memcpy(&raw_value_max, &tmp_value_max, sizeof(tmp_value_max));
+  if (raw_value_max != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteFloatToArray(
+        5, this->_internal_value_max(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target =
+        ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
+            _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:stream.PowerCompensate)
+  return target;
+}
+
+::size_t PowerCompensate::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:stream.PowerCompensate)
+  ::size_t total_size = 0;
+
+  ::uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // int32 cno = 1;
+  if (this->_internal_cno() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
+        this->_internal_cno());
+  }
+
+  // int32 percent = 2;
+  if (this->_internal_percent() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
+        this->_internal_percent());
+  }
+
+  // float value = 3;
+  static_assert(sizeof(::uint32_t) == sizeof(float),
+                "Code assumes ::uint32_t and float are the same size.");
+  float tmp_value = this->_internal_value();
+  ::uint32_t raw_value;
+  memcpy(&raw_value, &tmp_value, sizeof(tmp_value));
+  if (raw_value != 0) {
+    total_size += 5;
+  }
+
+  // float value_min = 4;
+  static_assert(sizeof(::uint32_t) == sizeof(float),
+                "Code assumes ::uint32_t and float are the same size.");
+  float tmp_value_min = this->_internal_value_min();
+  ::uint32_t raw_value_min;
+  memcpy(&raw_value_min, &tmp_value_min, sizeof(tmp_value_min));
+  if (raw_value_min != 0) {
+    total_size += 5;
+  }
+
+  // float value_max = 5;
+  static_assert(sizeof(::uint32_t) == sizeof(float),
+                "Code assumes ::uint32_t and float are the same size.");
+  float tmp_value_max = this->_internal_value_max();
+  ::uint32_t raw_value_max;
+  memcpy(&raw_value_max, &tmp_value_max, sizeof(tmp_value_max));
+  if (raw_value_max != 0) {
+    total_size += 5;
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::google::protobuf::Message::ClassData PowerCompensate::_class_data_ = {
+    ::google::protobuf::Message::CopyWithSourceCheck,
+    PowerCompensate::MergeImpl
+};
+const ::google::protobuf::Message::ClassData*PowerCompensate::GetClassData() const { return &_class_data_; }
+
+
+void PowerCompensate::MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg) {
+  auto* const _this = static_cast<PowerCompensate*>(&to_msg);
+  auto& from = static_cast<const PowerCompensate&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:stream.PowerCompensate)
+  ABSL_DCHECK_NE(&from, _this);
+  ::uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_cno() != 0) {
+    _this->_internal_set_cno(from._internal_cno());
+  }
+  if (from._internal_percent() != 0) {
+    _this->_internal_set_percent(from._internal_percent());
+  }
+  static_assert(sizeof(::uint32_t) == sizeof(float),
+                "Code assumes ::uint32_t and float are the same size.");
+  float tmp_value = from._internal_value();
+  ::uint32_t raw_value;
+  memcpy(&raw_value, &tmp_value, sizeof(tmp_value));
+  if (raw_value != 0) {
+    _this->_internal_set_value(from._internal_value());
+  }
+  static_assert(sizeof(::uint32_t) == sizeof(float),
+                "Code assumes ::uint32_t and float are the same size.");
+  float tmp_value_min = from._internal_value_min();
+  ::uint32_t raw_value_min;
+  memcpy(&raw_value_min, &tmp_value_min, sizeof(tmp_value_min));
+  if (raw_value_min != 0) {
+    _this->_internal_set_value_min(from._internal_value_min());
+  }
+  static_assert(sizeof(::uint32_t) == sizeof(float),
+                "Code assumes ::uint32_t and float are the same size.");
+  float tmp_value_max = from._internal_value_max();
+  ::uint32_t raw_value_max;
+  memcpy(&raw_value_max, &tmp_value_max, sizeof(tmp_value_max));
+  if (raw_value_max != 0) {
+    _this->_internal_set_value_max(from._internal_value_max());
+  }
+  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void PowerCompensate::CopyFrom(const PowerCompensate& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:stream.PowerCompensate)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+PROTOBUF_NOINLINE bool PowerCompensate::IsInitialized() const {
+  return true;
+}
+
+void PowerCompensate::InternalSwap(PowerCompensate* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::google::protobuf::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(PowerCompensate, _impl_.value_max_)
+      + sizeof(PowerCompensate::_impl_.value_max_)
+      - PROTOBUF_FIELD_OFFSET(PowerCompensate, _impl_.cno_)>(
+          reinterpret_cast<char*>(&_impl_.cno_),
+          reinterpret_cast<char*>(&other->_impl_.cno_));
+}
+
+::google::protobuf::Metadata PowerCompensate::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_stream_2eproto_getter, &descriptor_table_stream_2eproto_once,
+      file_level_metadata_stream_2eproto[19]);
+}
+// ===================================================================
+
+class TimePowerCompensate::_Internal {
+ public:
+};
+
+TimePowerCompensate::TimePowerCompensate(::google::protobuf::Arena* arena)
+    : ::google::protobuf::Message(arena) {
+  SharedCtor(arena);
+  // @@protoc_insertion_point(arena_constructor:stream.TimePowerCompensate)
+}
+TimePowerCompensate::TimePowerCompensate(const TimePowerCompensate& from)
+    : ::google::protobuf::Message(), _impl_(from._impl_) {
+  _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
+      from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:stream.TimePowerCompensate)
+}
+inline void TimePowerCompensate::SharedCtor(::_pb::Arena* arena) {
+  (void)arena;
+  new (&_impl_) Impl_{
+      decltype(_impl_.id_){0},
+      decltype(_impl_.cno_){0},
+      decltype(_impl_.startminute_){0u},
+      decltype(_impl_.endminute_){0u},
+      decltype(_impl_.compensate_){0},
+      /*decltype(_impl_._cached_size_)*/ {},
+  };
+}
+TimePowerCompensate::~TimePowerCompensate() {
+  // @@protoc_insertion_point(destructor:stream.TimePowerCompensate)
+  _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
+  SharedDtor();
+}
+inline void TimePowerCompensate::SharedDtor() {
+  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
+}
+void TimePowerCompensate::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+PROTOBUF_NOINLINE void TimePowerCompensate::Clear() {
+// @@protoc_insertion_point(message_clear_start:stream.TimePowerCompensate)
+  ::uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  ::memset(&_impl_.id_, 0, static_cast<::size_t>(
+      reinterpret_cast<char*>(&_impl_.compensate_) -
+      reinterpret_cast<char*>(&_impl_.id_)) + sizeof(_impl_.compensate_));
+  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
+}
+
+const char* TimePowerCompensate::_InternalParse(
+    const char* ptr, ::_pbi::ParseContext* ctx) {
+  ptr = ::_pbi::TcParser::ParseLoop(this, ptr, ctx, &_table_.header);
+  return ptr;
+}
+
+
+PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
+const ::_pbi::TcParseTable<3, 5, 0, 0, 2> TimePowerCompensate::_table_ = {
+  {
+    0,  // no _has_bits_
+    0, // no _extensions_
+    5, 56,  // max_field_number, fast_idx_mask
+    offsetof(decltype(_table_), field_lookup_table),
+    4294967264,  // skipmap
+    offsetof(decltype(_table_), field_entries),
+    5,  // num_field_entries
+    0,  // num_aux_entries
+    offsetof(decltype(_table_), field_names),  // no aux_entries
+    &_TimePowerCompensate_default_instance_._instance,
+    ::_pbi::TcParser::GenericFallback,  // fallback
+  }, {{
+    {::_pbi::TcParser::MiniParse, {}},
+    // int32 id = 1;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(TimePowerCompensate, _impl_.id_), 63>(),
+     {8, 63, 0, PROTOBUF_FIELD_OFFSET(TimePowerCompensate, _impl_.id_)}},
+    // int32 cno = 2;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(TimePowerCompensate, _impl_.cno_), 63>(),
+     {16, 63, 0, PROTOBUF_FIELD_OFFSET(TimePowerCompensate, _impl_.cno_)}},
+    // uint32 startMinute = 3;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(TimePowerCompensate, _impl_.startminute_), 63>(),
+     {24, 63, 0, PROTOBUF_FIELD_OFFSET(TimePowerCompensate, _impl_.startminute_)}},
+    // uint32 endMinute = 4;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(TimePowerCompensate, _impl_.endminute_), 63>(),
+     {32, 63, 0, PROTOBUF_FIELD_OFFSET(TimePowerCompensate, _impl_.endminute_)}},
+    // float compensate = 5;
+    {::_pbi::TcParser::FastF32S1,
+     {45, 63, 0, PROTOBUF_FIELD_OFFSET(TimePowerCompensate, _impl_.compensate_)}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+  }}, {{
+    65535, 65535
+  }}, {{
+    // int32 id = 1;
+    {PROTOBUF_FIELD_OFFSET(TimePowerCompensate, _impl_.id_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt32)},
+    // int32 cno = 2;
+    {PROTOBUF_FIELD_OFFSET(TimePowerCompensate, _impl_.cno_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt32)},
+    // uint32 startMinute = 3;
+    {PROTOBUF_FIELD_OFFSET(TimePowerCompensate, _impl_.startminute_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kUInt32)},
+    // uint32 endMinute = 4;
+    {PROTOBUF_FIELD_OFFSET(TimePowerCompensate, _impl_.endminute_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kUInt32)},
+    // float compensate = 5;
+    {PROTOBUF_FIELD_OFFSET(TimePowerCompensate, _impl_.compensate_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kFloat)},
+  }},
+  // no aux_entries
+  {{
+  }},
+};
+
+::uint8_t* TimePowerCompensate::_InternalSerialize(
+    ::uint8_t* target,
+    ::google::protobuf::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:stream.TimePowerCompensate)
+  ::uint32_t cached_has_bits = 0;
+  (void)cached_has_bits;
+
+  // int32 id = 1;
+  if (this->_internal_id() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt32ToArrayWithField<1>(
+            stream, this->_internal_id(), target);
+  }
+
+  // int32 cno = 2;
+  if (this->_internal_cno() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt32ToArrayWithField<2>(
+            stream, this->_internal_cno(), target);
+  }
+
+  // uint32 startMinute = 3;
+  if (this->_internal_startminute() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
+        3, this->_internal_startminute(), target);
+  }
+
+  // uint32 endMinute = 4;
+  if (this->_internal_endminute() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
+        4, this->_internal_endminute(), target);
+  }
+
+  // float compensate = 5;
+  static_assert(sizeof(::uint32_t) == sizeof(float),
+                "Code assumes ::uint32_t and float are the same size.");
+  float tmp_compensate = this->_internal_compensate();
+  ::uint32_t raw_compensate;
+  memcpy(&raw_compensate, &tmp_compensate, sizeof(tmp_compensate));
+  if (raw_compensate != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteFloatToArray(
+        5, this->_internal_compensate(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target =
+        ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
+            _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:stream.TimePowerCompensate)
+  return target;
+}
+
+::size_t TimePowerCompensate::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:stream.TimePowerCompensate)
+  ::size_t total_size = 0;
+
+  ::uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // int32 id = 1;
+  if (this->_internal_id() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
+        this->_internal_id());
+  }
+
+  // int32 cno = 2;
+  if (this->_internal_cno() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
+        this->_internal_cno());
+  }
+
+  // uint32 startMinute = 3;
+  if (this->_internal_startminute() != 0) {
+    total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
+        this->_internal_startminute());
+  }
+
+  // uint32 endMinute = 4;
+  if (this->_internal_endminute() != 0) {
+    total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
+        this->_internal_endminute());
+  }
+
+  // float compensate = 5;
+  static_assert(sizeof(::uint32_t) == sizeof(float),
+                "Code assumes ::uint32_t and float are the same size.");
+  float tmp_compensate = this->_internal_compensate();
+  ::uint32_t raw_compensate;
+  memcpy(&raw_compensate, &tmp_compensate, sizeof(tmp_compensate));
+  if (raw_compensate != 0) {
+    total_size += 5;
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::google::protobuf::Message::ClassData TimePowerCompensate::_class_data_ = {
+    ::google::protobuf::Message::CopyWithSourceCheck,
+    TimePowerCompensate::MergeImpl
+};
+const ::google::protobuf::Message::ClassData*TimePowerCompensate::GetClassData() const { return &_class_data_; }
+
+
+void TimePowerCompensate::MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg) {
+  auto* const _this = static_cast<TimePowerCompensate*>(&to_msg);
+  auto& from = static_cast<const TimePowerCompensate&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:stream.TimePowerCompensate)
+  ABSL_DCHECK_NE(&from, _this);
+  ::uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_id() != 0) {
+    _this->_internal_set_id(from._internal_id());
+  }
+  if (from._internal_cno() != 0) {
+    _this->_internal_set_cno(from._internal_cno());
+  }
+  if (from._internal_startminute() != 0) {
+    _this->_internal_set_startminute(from._internal_startminute());
+  }
+  if (from._internal_endminute() != 0) {
+    _this->_internal_set_endminute(from._internal_endminute());
+  }
+  static_assert(sizeof(::uint32_t) == sizeof(float),
+                "Code assumes ::uint32_t and float are the same size.");
+  float tmp_compensate = from._internal_compensate();
+  ::uint32_t raw_compensate;
+  memcpy(&raw_compensate, &tmp_compensate, sizeof(tmp_compensate));
+  if (raw_compensate != 0) {
+    _this->_internal_set_compensate(from._internal_compensate());
+  }
+  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void TimePowerCompensate::CopyFrom(const TimePowerCompensate& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:stream.TimePowerCompensate)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+PROTOBUF_NOINLINE bool TimePowerCompensate::IsInitialized() const {
+  return true;
+}
+
+void TimePowerCompensate::InternalSwap(TimePowerCompensate* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::google::protobuf::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(TimePowerCompensate, _impl_.compensate_)
+      + sizeof(TimePowerCompensate::_impl_.compensate_)
+      - PROTOBUF_FIELD_OFFSET(TimePowerCompensate, _impl_.id_)>(
+          reinterpret_cast<char*>(&_impl_.id_),
+          reinterpret_cast<char*>(&other->_impl_.id_));
+}
+
+::google::protobuf::Metadata TimePowerCompensate::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_stream_2eproto_getter, &descriptor_table_stream_2eproto_once,
+      file_level_metadata_stream_2eproto[20]);
+}
 // @@protoc_insertion_point(namespace_scope)
 }  // namespace stream
 namespace google {
diff --git a/PrintS/protobuf/stream.pb.h b/PrintS/protobuf/stream.pb.h
index 4fd7990..f1a7c96 100644
--- a/PrintS/protobuf/stream.pb.h
+++ b/PrintS/protobuf/stream.pb.h
@@ -62,6 +62,12 @@ extern ChainDataBlockDefaultTypeInternal _ChainDataBlock_default_instance_;
 class ComResponce;
 struct ComResponceDefaultTypeInternal;
 extern ComResponceDefaultTypeInternal _ComResponce_default_instance_;
+class CorrectParamCfg;
+struct CorrectParamCfgDefaultTypeInternal;
+extern CorrectParamCfgDefaultTypeInternal _CorrectParamCfg_default_instance_;
+class FixPointData;
+struct FixPointDataDefaultTypeInternal;
+extern FixPointDataDefaultTypeInternal _FixPointData_default_instance_;
 class ImgInfoResponce;
 struct ImgInfoResponceDefaultTypeInternal;
 extern ImgInfoResponceDefaultTypeInternal _ImgInfoResponce_default_instance_;
@@ -77,6 +83,9 @@ extern ParamInfoDefaultTypeInternal _ParamInfo_default_instance_;
 class Point;
 struct PointDefaultTypeInternal;
 extern PointDefaultTypeInternal _Point_default_instance_;
+class PowerCompensate;
+struct PowerCompensateDefaultTypeInternal;
+extern PowerCompensateDefaultTypeInternal _PowerCompensate_default_instance_;
 class RegResponce;
 struct RegResponceDefaultTypeInternal;
 extern RegResponceDefaultTypeInternal _RegResponce_default_instance_;
@@ -89,6 +98,24 @@ extern ResponseAnyDefaultTypeInternal _ResponseAny_default_instance_;
 class ResponseInfo;
 struct ResponseInfoDefaultTypeInternal;
 extern ResponseInfoDefaultTypeInternal _ResponseInfo_default_instance_;
+class ScanParamCfg;
+struct ScanParamCfgDefaultTypeInternal;
+extern ScanParamCfgDefaultTypeInternal _ScanParamCfg_default_instance_;
+class ScanTestCfg;
+struct ScanTestCfgDefaultTypeInternal;
+extern ScanTestCfgDefaultTypeInternal _ScanTestCfg_default_instance_;
+class ScannerCrtlCfgData;
+struct ScannerCrtlCfgDataDefaultTypeInternal;
+extern ScannerCrtlCfgDataDefaultTypeInternal _ScannerCrtlCfgData_default_instance_;
+class ScannerCrtlCfgResp;
+struct ScannerCrtlCfgRespDefaultTypeInternal;
+extern ScannerCrtlCfgRespDefaultTypeInternal _ScannerCrtlCfgResp_default_instance_;
+class SkyWritingCfg;
+struct SkyWritingCfgDefaultTypeInternal;
+extern SkyWritingCfgDefaultTypeInternal _SkyWritingCfg_default_instance_;
+class TimePowerCompensate;
+struct TimePowerCompensateDefaultTypeInternal;
+extern TimePowerCompensateDefaultTypeInternal _TimePowerCompensate_default_instance_;
 class VectorDataBlock;
 struct VectorDataBlockDefaultTypeInternal;
 extern VectorDataBlockDefaultTypeInternal _VectorDataBlock_default_instance_;
@@ -311,13 +338,21 @@ class ParamInfo final :
     kNameKeyFieldNumber = 1,
     kStrValueFieldNumber = 2,
     kContextFieldNumber = 4,
+    kCardNameFieldNumber = 15,
+    kCardIPFieldNumber = 16,
     kValueTypeFieldNumber = 3,
+    kStartLayerFieldNumber = 8,
     kIsEnableFieldNumber = 5,
     kIsAlarmFieldNumber = 6,
     kIsShowFieldNumber = 7,
-    kStartLayerFieldNumber = 8,
+    kHadAssignFieldNumber = 17,
     kEndLayerFieldNumber = 9,
     kPowderFieldNumber = 10,
+    kSeqNoFieldNumber = 11,
+    kControlNoFieldNumber = 12,
+    kSerialNoFieldNumber = 13,
+    kControlTypeFieldNumber = 14,
+    kHadMatchFieldNumber = 18,
   };
   // bytes nameKey = 1;
   void clear_namekey() ;
@@ -366,6 +401,38 @@ class ParamInfo final :
       const std::string& value);
   std::string* _internal_mutable_context();
 
+  public:
+  // bytes cardName = 15;
+  void clear_cardname() ;
+  const std::string& cardname() const;
+  template <typename Arg_ = const std::string&, typename... Args_>
+  void set_cardname(Arg_&& arg, Args_... args);
+  std::string* mutable_cardname();
+  PROTOBUF_NODISCARD std::string* release_cardname();
+  void set_allocated_cardname(std::string* ptr);
+
+  private:
+  const std::string& _internal_cardname() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_cardname(
+      const std::string& value);
+  std::string* _internal_mutable_cardname();
+
+  public:
+  // bytes cardIP = 16;
+  void clear_cardip() ;
+  const std::string& cardip() const;
+  template <typename Arg_ = const std::string&, typename... Args_>
+  void set_cardip(Arg_&& arg, Args_... args);
+  std::string* mutable_cardip();
+  PROTOBUF_NODISCARD std::string* release_cardip();
+  void set_allocated_cardip(std::string* ptr);
+
+  private:
+  const std::string& _internal_cardip() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_cardip(
+      const std::string& value);
+  std::string* _internal_mutable_cardip();
+
   public:
   // .stream.TYPE valueType = 3;
   void clear_valuetype() ;
@@ -376,6 +443,16 @@ class ParamInfo final :
   ::stream::TYPE _internal_valuetype() const;
   void _internal_set_valuetype(::stream::TYPE value);
 
+  public:
+  // int32 startLayer = 8;
+  void clear_startlayer() ;
+  ::int32_t startlayer() const;
+  void set_startlayer(::int32_t value);
+
+  private:
+  ::int32_t _internal_startlayer() const;
+  void _internal_set_startlayer(::int32_t value);
+
   public:
   // bool isEnable = 5;
   void clear_isenable() ;
@@ -407,14 +484,14 @@ class ParamInfo final :
   void _internal_set_isshow(bool value);
 
   public:
-  // int32 startLayer = 8;
-  void clear_startlayer() ;
-  ::int32_t startlayer() const;
-  void set_startlayer(::int32_t value);
+  // bool hadAssign = 17;
+  void clear_hadassign() ;
+  bool hadassign() const;
+  void set_hadassign(bool value);
 
   private:
-  ::int32_t _internal_startlayer() const;
-  void _internal_set_startlayer(::int32_t value);
+  bool _internal_hadassign() const;
+  void _internal_set_hadassign(bool value);
 
   public:
   // int32 endLayer = 9;
@@ -436,13 +513,63 @@ class ParamInfo final :
   float _internal_powder() const;
   void _internal_set_powder(float value);
 
+  public:
+  // int32 seqNo = 11;
+  void clear_seqno() ;
+  ::int32_t seqno() const;
+  void set_seqno(::int32_t value);
+
+  private:
+  ::int32_t _internal_seqno() const;
+  void _internal_set_seqno(::int32_t value);
+
+  public:
+  // int32 controlNo = 12;
+  void clear_controlno() ;
+  ::int32_t controlno() const;
+  void set_controlno(::int32_t value);
+
+  private:
+  ::int32_t _internal_controlno() const;
+  void _internal_set_controlno(::int32_t value);
+
+  public:
+  // int32 serialNo = 13;
+  void clear_serialno() ;
+  ::int32_t serialno() const;
+  void set_serialno(::int32_t value);
+
+  private:
+  ::int32_t _internal_serialno() const;
+  void _internal_set_serialno(::int32_t value);
+
+  public:
+  // int32 controlType = 14;
+  void clear_controltype() ;
+  ::int32_t controltype() const;
+  void set_controltype(::int32_t value);
+
+  private:
+  ::int32_t _internal_controltype() const;
+  void _internal_set_controltype(::int32_t value);
+
+  public:
+  // bool hadMatch = 18;
+  void clear_hadmatch() ;
+  bool hadmatch() const;
+  void set_hadmatch(bool value);
+
+  private:
+  bool _internal_hadmatch() const;
+  void _internal_set_hadmatch(bool value);
+
   public:
   // @@protoc_insertion_point(class_scope:stream.ParamInfo)
  private:
   class _Internal;
 
   friend class ::google::protobuf::internal::TcParser;
-  static const ::google::protobuf::internal::TcParseTable<4, 10, 0, 0, 2> _table_;
+  static const ::google::protobuf::internal::TcParseTable<5, 18, 0, 0, 2> _table_;
   template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
   typedef void InternalArenaConstructable_;
   typedef void DestructorSkippable_;
@@ -450,13 +577,21 @@ class ParamInfo final :
     ::google::protobuf::internal::ArenaStringPtr namekey_;
     ::google::protobuf::internal::ArenaStringPtr strvalue_;
     ::google::protobuf::internal::ArenaStringPtr context_;
+    ::google::protobuf::internal::ArenaStringPtr cardname_;
+    ::google::protobuf::internal::ArenaStringPtr cardip_;
     int valuetype_;
+    ::int32_t startlayer_;
     bool isenable_;
     bool isalarm_;
     bool isshow_;
-    ::int32_t startlayer_;
+    bool hadassign_;
     ::int32_t endlayer_;
     float powder_;
+    ::int32_t seqno_;
+    ::int32_t controlno_;
+    ::int32_t serialno_;
+    ::int32_t controltype_;
+    bool hadmatch_;
     mutable ::google::protobuf::internal::CachedSize _cached_size_;
     PROTOBUF_TSAN_DECLARE_MEMBER
   };
@@ -2548,6 +2683,2960 @@ class ComResponce final :
   };
   union { Impl_ _impl_; };
   friend struct ::TableStruct_stream_2eproto;
+};// -------------------------------------------------------------------
+
+class ScannerCrtlCfgResp final :
+    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:stream.ScannerCrtlCfgResp) */ {
+ public:
+  inline ScannerCrtlCfgResp() : ScannerCrtlCfgResp(nullptr) {}
+  ~ScannerCrtlCfgResp() override;
+  template<typename = void>
+  explicit PROTOBUF_CONSTEXPR ScannerCrtlCfgResp(::google::protobuf::internal::ConstantInitialized);
+
+  ScannerCrtlCfgResp(const ScannerCrtlCfgResp& from);
+  ScannerCrtlCfgResp(ScannerCrtlCfgResp&& from) noexcept
+    : ScannerCrtlCfgResp() {
+    *this = ::std::move(from);
+  }
+
+  inline ScannerCrtlCfgResp& operator=(const ScannerCrtlCfgResp& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ScannerCrtlCfgResp& operator=(ScannerCrtlCfgResp&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
+  }
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::google::protobuf::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::google::protobuf::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ScannerCrtlCfgResp& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ScannerCrtlCfgResp* internal_default_instance() {
+    return reinterpret_cast<const ScannerCrtlCfgResp*>(
+               &_ScannerCrtlCfgResp_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    12;
+
+  friend void swap(ScannerCrtlCfgResp& a, ScannerCrtlCfgResp& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ScannerCrtlCfgResp* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::google::protobuf::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ScannerCrtlCfgResp* other) {
+    if (other == this) return;
+    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ScannerCrtlCfgResp* New(::google::protobuf::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ScannerCrtlCfgResp>(arena);
+  }
+  using ::google::protobuf::Message::CopyFrom;
+  void CopyFrom(const ScannerCrtlCfgResp& from);
+  using ::google::protobuf::Message::MergeFrom;
+  void MergeFrom( const ScannerCrtlCfgResp& from) {
+    ScannerCrtlCfgResp::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  ::size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
+  ::uint8_t* _InternalSerialize(
+      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::google::protobuf::Arena* arena);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ScannerCrtlCfgResp* other);
+
+  private:
+  friend class ::google::protobuf::internal::AnyMetadata;
+  static ::absl::string_view FullMessageName() {
+    return "stream.ScannerCrtlCfgResp";
+  }
+  protected:
+  explicit ScannerCrtlCfgResp(::google::protobuf::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::google::protobuf::Message::ClassData*GetClassData() const final;
+
+  ::google::protobuf::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kScannerCfgFieldNumber = 1,
+  };
+  // repeated .stream.ScannerCrtlCfgData scannerCfg = 1;
+  int scannercfg_size() const;
+  private:
+  int _internal_scannercfg_size() const;
+
+  public:
+  void clear_scannercfg() ;
+  ::stream::ScannerCrtlCfgData* mutable_scannercfg(int index);
+  ::google::protobuf::RepeatedPtrField< ::stream::ScannerCrtlCfgData >*
+      mutable_scannercfg();
+  private:
+  const ::google::protobuf::RepeatedPtrField<::stream::ScannerCrtlCfgData>& _internal_scannercfg() const;
+  ::google::protobuf::RepeatedPtrField<::stream::ScannerCrtlCfgData>* _internal_mutable_scannercfg();
+  public:
+  const ::stream::ScannerCrtlCfgData& scannercfg(int index) const;
+  ::stream::ScannerCrtlCfgData* add_scannercfg();
+  const ::google::protobuf::RepeatedPtrField< ::stream::ScannerCrtlCfgData >&
+      scannercfg() const;
+  // @@protoc_insertion_point(class_scope:stream.ScannerCrtlCfgResp)
+ private:
+  class _Internal;
+
+  friend class ::google::protobuf::internal::TcParser;
+  static const ::google::protobuf::internal::TcParseTable<0, 1, 1, 0, 2> _table_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::google::protobuf::RepeatedPtrField< ::stream::ScannerCrtlCfgData > scannercfg_;
+    mutable ::google::protobuf::internal::CachedSize _cached_size_;
+    PROTOBUF_TSAN_DECLARE_MEMBER
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_stream_2eproto;
+};// -------------------------------------------------------------------
+
+class ScannerCrtlCfgData final :
+    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:stream.ScannerCrtlCfgData) */ {
+ public:
+  inline ScannerCrtlCfgData() : ScannerCrtlCfgData(nullptr) {}
+  ~ScannerCrtlCfgData() override;
+  template<typename = void>
+  explicit PROTOBUF_CONSTEXPR ScannerCrtlCfgData(::google::protobuf::internal::ConstantInitialized);
+
+  ScannerCrtlCfgData(const ScannerCrtlCfgData& from);
+  ScannerCrtlCfgData(ScannerCrtlCfgData&& from) noexcept
+    : ScannerCrtlCfgData() {
+    *this = ::std::move(from);
+  }
+
+  inline ScannerCrtlCfgData& operator=(const ScannerCrtlCfgData& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ScannerCrtlCfgData& operator=(ScannerCrtlCfgData&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
+  }
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::google::protobuf::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::google::protobuf::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ScannerCrtlCfgData& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ScannerCrtlCfgData* internal_default_instance() {
+    return reinterpret_cast<const ScannerCrtlCfgData*>(
+               &_ScannerCrtlCfgData_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    13;
+
+  friend void swap(ScannerCrtlCfgData& a, ScannerCrtlCfgData& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ScannerCrtlCfgData* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::google::protobuf::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ScannerCrtlCfgData* other) {
+    if (other == this) return;
+    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ScannerCrtlCfgData* New(::google::protobuf::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ScannerCrtlCfgData>(arena);
+  }
+  using ::google::protobuf::Message::CopyFrom;
+  void CopyFrom(const ScannerCrtlCfgData& from);
+  using ::google::protobuf::Message::MergeFrom;
+  void MergeFrom( const ScannerCrtlCfgData& from) {
+    ScannerCrtlCfgData::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  ::size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
+  ::uint8_t* _InternalSerialize(
+      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::google::protobuf::Arena* arena);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ScannerCrtlCfgData* other);
+
+  private:
+  friend class ::google::protobuf::internal::AnyMetadata;
+  static ::absl::string_view FullMessageName() {
+    return "stream.ScannerCrtlCfgData";
+  }
+  protected:
+  explicit ScannerCrtlCfgData(::google::protobuf::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::google::protobuf::Message::ClassData*GetClassData() const final;
+
+  ::google::protobuf::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kFixPointDataFieldNumber = 2,
+    kPowerCompensateFieldNumber = 10,
+    kTPowerCompensateFieldNumber = 11,
+    kCardNameFieldNumber = 15,
+    kCardIPFieldNumber = 16,
+    kScanParamCfgFieldNumber = 3,
+    kHatchingParamsFieldNumber = 4,
+    kBorderParamsFieldNumber = 5,
+    kSupportParamsFieldNumber = 6,
+    kCorrectParamCfgFieldNumber = 7,
+    kScanTestCfgFieldNumber = 8,
+    kSkyWritingCfgFieldNumber = 9,
+    kSeqNoFieldNumber = 1,
+    kControlNoFieldNumber = 12,
+    kSerialNoFieldNumber = 13,
+    kControlTypeFieldNumber = 14,
+    kIsEnableFieldNumber = 17,
+    kHadAssignFieldNumber = 18,
+    kHadMatchFieldNumber = 19,
+  };
+  // repeated .stream.FixPointData fixPointData = 2;
+  int fixpointdata_size() const;
+  private:
+  int _internal_fixpointdata_size() const;
+
+  public:
+  void clear_fixpointdata() ;
+  ::stream::FixPointData* mutable_fixpointdata(int index);
+  ::google::protobuf::RepeatedPtrField< ::stream::FixPointData >*
+      mutable_fixpointdata();
+  private:
+  const ::google::protobuf::RepeatedPtrField<::stream::FixPointData>& _internal_fixpointdata() const;
+  ::google::protobuf::RepeatedPtrField<::stream::FixPointData>* _internal_mutable_fixpointdata();
+  public:
+  const ::stream::FixPointData& fixpointdata(int index) const;
+  ::stream::FixPointData* add_fixpointdata();
+  const ::google::protobuf::RepeatedPtrField< ::stream::FixPointData >&
+      fixpointdata() const;
+  // repeated .stream.PowerCompensate powerCompensate = 10;
+  int powercompensate_size() const;
+  private:
+  int _internal_powercompensate_size() const;
+
+  public:
+  void clear_powercompensate() ;
+  ::stream::PowerCompensate* mutable_powercompensate(int index);
+  ::google::protobuf::RepeatedPtrField< ::stream::PowerCompensate >*
+      mutable_powercompensate();
+  private:
+  const ::google::protobuf::RepeatedPtrField<::stream::PowerCompensate>& _internal_powercompensate() const;
+  ::google::protobuf::RepeatedPtrField<::stream::PowerCompensate>* _internal_mutable_powercompensate();
+  public:
+  const ::stream::PowerCompensate& powercompensate(int index) const;
+  ::stream::PowerCompensate* add_powercompensate();
+  const ::google::protobuf::RepeatedPtrField< ::stream::PowerCompensate >&
+      powercompensate() const;
+  // repeated .stream.TimePowerCompensate tPowerCompensate = 11;
+  int tpowercompensate_size() const;
+  private:
+  int _internal_tpowercompensate_size() const;
+
+  public:
+  void clear_tpowercompensate() ;
+  ::stream::TimePowerCompensate* mutable_tpowercompensate(int index);
+  ::google::protobuf::RepeatedPtrField< ::stream::TimePowerCompensate >*
+      mutable_tpowercompensate();
+  private:
+  const ::google::protobuf::RepeatedPtrField<::stream::TimePowerCompensate>& _internal_tpowercompensate() const;
+  ::google::protobuf::RepeatedPtrField<::stream::TimePowerCompensate>* _internal_mutable_tpowercompensate();
+  public:
+  const ::stream::TimePowerCompensate& tpowercompensate(int index) const;
+  ::stream::TimePowerCompensate* add_tpowercompensate();
+  const ::google::protobuf::RepeatedPtrField< ::stream::TimePowerCompensate >&
+      tpowercompensate() const;
+  // bytes cardName = 15;
+  void clear_cardname() ;
+  const std::string& cardname() const;
+  template <typename Arg_ = const std::string&, typename... Args_>
+  void set_cardname(Arg_&& arg, Args_... args);
+  std::string* mutable_cardname();
+  PROTOBUF_NODISCARD std::string* release_cardname();
+  void set_allocated_cardname(std::string* ptr);
+
+  private:
+  const std::string& _internal_cardname() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_cardname(
+      const std::string& value);
+  std::string* _internal_mutable_cardname();
+
+  public:
+  // bytes cardIP = 16;
+  void clear_cardip() ;
+  const std::string& cardip() const;
+  template <typename Arg_ = const std::string&, typename... Args_>
+  void set_cardip(Arg_&& arg, Args_... args);
+  std::string* mutable_cardip();
+  PROTOBUF_NODISCARD std::string* release_cardip();
+  void set_allocated_cardip(std::string* ptr);
+
+  private:
+  const std::string& _internal_cardip() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_cardip(
+      const std::string& value);
+  std::string* _internal_mutable_cardip();
+
+  public:
+  // .stream.ScanParamCfg scanParamCfg = 3;
+  bool has_scanparamcfg() const;
+  void clear_scanparamcfg() ;
+  const ::stream::ScanParamCfg& scanparamcfg() const;
+  PROTOBUF_NODISCARD ::stream::ScanParamCfg* release_scanparamcfg();
+  ::stream::ScanParamCfg* mutable_scanparamcfg();
+  void set_allocated_scanparamcfg(::stream::ScanParamCfg* value);
+  void unsafe_arena_set_allocated_scanparamcfg(::stream::ScanParamCfg* value);
+  ::stream::ScanParamCfg* unsafe_arena_release_scanparamcfg();
+
+  private:
+  const ::stream::ScanParamCfg& _internal_scanparamcfg() const;
+  ::stream::ScanParamCfg* _internal_mutable_scanparamcfg();
+
+  public:
+  // .stream.ScanParamCfg hatchingParams = 4;
+  bool has_hatchingparams() const;
+  void clear_hatchingparams() ;
+  const ::stream::ScanParamCfg& hatchingparams() const;
+  PROTOBUF_NODISCARD ::stream::ScanParamCfg* release_hatchingparams();
+  ::stream::ScanParamCfg* mutable_hatchingparams();
+  void set_allocated_hatchingparams(::stream::ScanParamCfg* value);
+  void unsafe_arena_set_allocated_hatchingparams(::stream::ScanParamCfg* value);
+  ::stream::ScanParamCfg* unsafe_arena_release_hatchingparams();
+
+  private:
+  const ::stream::ScanParamCfg& _internal_hatchingparams() const;
+  ::stream::ScanParamCfg* _internal_mutable_hatchingparams();
+
+  public:
+  // .stream.ScanParamCfg borderParams = 5;
+  bool has_borderparams() const;
+  void clear_borderparams() ;
+  const ::stream::ScanParamCfg& borderparams() const;
+  PROTOBUF_NODISCARD ::stream::ScanParamCfg* release_borderparams();
+  ::stream::ScanParamCfg* mutable_borderparams();
+  void set_allocated_borderparams(::stream::ScanParamCfg* value);
+  void unsafe_arena_set_allocated_borderparams(::stream::ScanParamCfg* value);
+  ::stream::ScanParamCfg* unsafe_arena_release_borderparams();
+
+  private:
+  const ::stream::ScanParamCfg& _internal_borderparams() const;
+  ::stream::ScanParamCfg* _internal_mutable_borderparams();
+
+  public:
+  // .stream.ScanParamCfg supportParams = 6;
+  bool has_supportparams() const;
+  void clear_supportparams() ;
+  const ::stream::ScanParamCfg& supportparams() const;
+  PROTOBUF_NODISCARD ::stream::ScanParamCfg* release_supportparams();
+  ::stream::ScanParamCfg* mutable_supportparams();
+  void set_allocated_supportparams(::stream::ScanParamCfg* value);
+  void unsafe_arena_set_allocated_supportparams(::stream::ScanParamCfg* value);
+  ::stream::ScanParamCfg* unsafe_arena_release_supportparams();
+
+  private:
+  const ::stream::ScanParamCfg& _internal_supportparams() const;
+  ::stream::ScanParamCfg* _internal_mutable_supportparams();
+
+  public:
+  // .stream.CorrectParamCfg correctParamCfg = 7;
+  bool has_correctparamcfg() const;
+  void clear_correctparamcfg() ;
+  const ::stream::CorrectParamCfg& correctparamcfg() const;
+  PROTOBUF_NODISCARD ::stream::CorrectParamCfg* release_correctparamcfg();
+  ::stream::CorrectParamCfg* mutable_correctparamcfg();
+  void set_allocated_correctparamcfg(::stream::CorrectParamCfg* value);
+  void unsafe_arena_set_allocated_correctparamcfg(::stream::CorrectParamCfg* value);
+  ::stream::CorrectParamCfg* unsafe_arena_release_correctparamcfg();
+
+  private:
+  const ::stream::CorrectParamCfg& _internal_correctparamcfg() const;
+  ::stream::CorrectParamCfg* _internal_mutable_correctparamcfg();
+
+  public:
+  // .stream.ScanTestCfg scanTestCfg = 8;
+  bool has_scantestcfg() const;
+  void clear_scantestcfg() ;
+  const ::stream::ScanTestCfg& scantestcfg() const;
+  PROTOBUF_NODISCARD ::stream::ScanTestCfg* release_scantestcfg();
+  ::stream::ScanTestCfg* mutable_scantestcfg();
+  void set_allocated_scantestcfg(::stream::ScanTestCfg* value);
+  void unsafe_arena_set_allocated_scantestcfg(::stream::ScanTestCfg* value);
+  ::stream::ScanTestCfg* unsafe_arena_release_scantestcfg();
+
+  private:
+  const ::stream::ScanTestCfg& _internal_scantestcfg() const;
+  ::stream::ScanTestCfg* _internal_mutable_scantestcfg();
+
+  public:
+  // .stream.SkyWritingCfg skyWritingCfg = 9;
+  bool has_skywritingcfg() const;
+  void clear_skywritingcfg() ;
+  const ::stream::SkyWritingCfg& skywritingcfg() const;
+  PROTOBUF_NODISCARD ::stream::SkyWritingCfg* release_skywritingcfg();
+  ::stream::SkyWritingCfg* mutable_skywritingcfg();
+  void set_allocated_skywritingcfg(::stream::SkyWritingCfg* value);
+  void unsafe_arena_set_allocated_skywritingcfg(::stream::SkyWritingCfg* value);
+  ::stream::SkyWritingCfg* unsafe_arena_release_skywritingcfg();
+
+  private:
+  const ::stream::SkyWritingCfg& _internal_skywritingcfg() const;
+  ::stream::SkyWritingCfg* _internal_mutable_skywritingcfg();
+
+  public:
+  // int32 seqNo = 1;
+  void clear_seqno() ;
+  ::int32_t seqno() const;
+  void set_seqno(::int32_t value);
+
+  private:
+  ::int32_t _internal_seqno() const;
+  void _internal_set_seqno(::int32_t value);
+
+  public:
+  // int32 controlNo = 12;
+  void clear_controlno() ;
+  ::int32_t controlno() const;
+  void set_controlno(::int32_t value);
+
+  private:
+  ::int32_t _internal_controlno() const;
+  void _internal_set_controlno(::int32_t value);
+
+  public:
+  // int32 serialNo = 13;
+  void clear_serialno() ;
+  ::int32_t serialno() const;
+  void set_serialno(::int32_t value);
+
+  private:
+  ::int32_t _internal_serialno() const;
+  void _internal_set_serialno(::int32_t value);
+
+  public:
+  // int32 controlType = 14;
+  void clear_controltype() ;
+  ::int32_t controltype() const;
+  void set_controltype(::int32_t value);
+
+  private:
+  ::int32_t _internal_controltype() const;
+  void _internal_set_controltype(::int32_t value);
+
+  public:
+  // bool isEnable = 17;
+  void clear_isenable() ;
+  bool isenable() const;
+  void set_isenable(bool value);
+
+  private:
+  bool _internal_isenable() const;
+  void _internal_set_isenable(bool value);
+
+  public:
+  // bool hadAssign = 18;
+  void clear_hadassign() ;
+  bool hadassign() const;
+  void set_hadassign(bool value);
+
+  private:
+  bool _internal_hadassign() const;
+  void _internal_set_hadassign(bool value);
+
+  public:
+  // bool hadMatch = 19;
+  void clear_hadmatch() ;
+  bool hadmatch() const;
+  void set_hadmatch(bool value);
+
+  private:
+  bool _internal_hadmatch() const;
+  void _internal_set_hadmatch(bool value);
+
+  public:
+  // @@protoc_insertion_point(class_scope:stream.ScannerCrtlCfgData)
+ private:
+  class _Internal;
+
+  friend class ::google::protobuf::internal::TcParser;
+  static const ::google::protobuf::internal::TcParseTable<5, 19, 10, 0, 2> _table_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::google::protobuf::internal::HasBits<1> _has_bits_;
+    mutable ::google::protobuf::internal::CachedSize _cached_size_;
+    ::google::protobuf::RepeatedPtrField< ::stream::FixPointData > fixpointdata_;
+    ::google::protobuf::RepeatedPtrField< ::stream::PowerCompensate > powercompensate_;
+    ::google::protobuf::RepeatedPtrField< ::stream::TimePowerCompensate > tpowercompensate_;
+    ::google::protobuf::internal::ArenaStringPtr cardname_;
+    ::google::protobuf::internal::ArenaStringPtr cardip_;
+    ::stream::ScanParamCfg* scanparamcfg_;
+    ::stream::ScanParamCfg* hatchingparams_;
+    ::stream::ScanParamCfg* borderparams_;
+    ::stream::ScanParamCfg* supportparams_;
+    ::stream::CorrectParamCfg* correctparamcfg_;
+    ::stream::ScanTestCfg* scantestcfg_;
+    ::stream::SkyWritingCfg* skywritingcfg_;
+    ::int32_t seqno_;
+    ::int32_t controlno_;
+    ::int32_t serialno_;
+    ::int32_t controltype_;
+    bool isenable_;
+    bool hadassign_;
+    bool hadmatch_;
+    PROTOBUF_TSAN_DECLARE_MEMBER
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_stream_2eproto;
+};// -------------------------------------------------------------------
+
+class FixPointData final :
+    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:stream.FixPointData) */ {
+ public:
+  inline FixPointData() : FixPointData(nullptr) {}
+  ~FixPointData() override;
+  template<typename = void>
+  explicit PROTOBUF_CONSTEXPR FixPointData(::google::protobuf::internal::ConstantInitialized);
+
+  FixPointData(const FixPointData& from);
+  FixPointData(FixPointData&& from) noexcept
+    : FixPointData() {
+    *this = ::std::move(from);
+  }
+
+  inline FixPointData& operator=(const FixPointData& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline FixPointData& operator=(FixPointData&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
+  }
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::google::protobuf::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::google::protobuf::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const FixPointData& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const FixPointData* internal_default_instance() {
+    return reinterpret_cast<const FixPointData*>(
+               &_FixPointData_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    14;
+
+  friend void swap(FixPointData& a, FixPointData& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(FixPointData* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::google::protobuf::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(FixPointData* other) {
+    if (other == this) return;
+    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  FixPointData* New(::google::protobuf::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<FixPointData>(arena);
+  }
+  using ::google::protobuf::Message::CopyFrom;
+  void CopyFrom(const FixPointData& from);
+  using ::google::protobuf::Message::MergeFrom;
+  void MergeFrom( const FixPointData& from) {
+    FixPointData::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  ::size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
+  ::uint8_t* _InternalSerialize(
+      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::google::protobuf::Arena* arena);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(FixPointData* other);
+
+  private:
+  friend class ::google::protobuf::internal::AnyMetadata;
+  static ::absl::string_view FullMessageName() {
+    return "stream.FixPointData";
+  }
+  protected:
+  explicit FixPointData(::google::protobuf::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::google::protobuf::Message::ClassData*GetClassData() const final;
+
+  ::google::protobuf::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kIdFieldNumber = 1,
+    kCnoFieldNumber = 2,
+    kPointXFieldNumber = 3,
+    kPointYFieldNumber = 4,
+    kDurationFieldNumber = 5,
+  };
+  // int32 id = 1;
+  void clear_id() ;
+  ::int32_t id() const;
+  void set_id(::int32_t value);
+
+  private:
+  ::int32_t _internal_id() const;
+  void _internal_set_id(::int32_t value);
+
+  public:
+  // int32 cno = 2;
+  void clear_cno() ;
+  ::int32_t cno() const;
+  void set_cno(::int32_t value);
+
+  private:
+  ::int32_t _internal_cno() const;
+  void _internal_set_cno(::int32_t value);
+
+  public:
+  // float pointX = 3;
+  void clear_pointx() ;
+  float pointx() const;
+  void set_pointx(float value);
+
+  private:
+  float _internal_pointx() const;
+  void _internal_set_pointx(float value);
+
+  public:
+  // float pointY = 4;
+  void clear_pointy() ;
+  float pointy() const;
+  void set_pointy(float value);
+
+  private:
+  float _internal_pointy() const;
+  void _internal_set_pointy(float value);
+
+  public:
+  // uint32 duration = 5;
+  void clear_duration() ;
+  ::uint32_t duration() const;
+  void set_duration(::uint32_t value);
+
+  private:
+  ::uint32_t _internal_duration() const;
+  void _internal_set_duration(::uint32_t value);
+
+  public:
+  // @@protoc_insertion_point(class_scope:stream.FixPointData)
+ private:
+  class _Internal;
+
+  friend class ::google::protobuf::internal::TcParser;
+  static const ::google::protobuf::internal::TcParseTable<3, 5, 0, 0, 2> _table_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::int32_t id_;
+    ::int32_t cno_;
+    float pointx_;
+    float pointy_;
+    ::uint32_t duration_;
+    mutable ::google::protobuf::internal::CachedSize _cached_size_;
+    PROTOBUF_TSAN_DECLARE_MEMBER
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_stream_2eproto;
+};// -------------------------------------------------------------------
+
+class ScanParamCfg final :
+    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:stream.ScanParamCfg) */ {
+ public:
+  inline ScanParamCfg() : ScanParamCfg(nullptr) {}
+  ~ScanParamCfg() override;
+  template<typename = void>
+  explicit PROTOBUF_CONSTEXPR ScanParamCfg(::google::protobuf::internal::ConstantInitialized);
+
+  ScanParamCfg(const ScanParamCfg& from);
+  ScanParamCfg(ScanParamCfg&& from) noexcept
+    : ScanParamCfg() {
+    *this = ::std::move(from);
+  }
+
+  inline ScanParamCfg& operator=(const ScanParamCfg& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ScanParamCfg& operator=(ScanParamCfg&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
+  }
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::google::protobuf::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::google::protobuf::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ScanParamCfg& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ScanParamCfg* internal_default_instance() {
+    return reinterpret_cast<const ScanParamCfg*>(
+               &_ScanParamCfg_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    15;
+
+  friend void swap(ScanParamCfg& a, ScanParamCfg& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ScanParamCfg* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::google::protobuf::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ScanParamCfg* other) {
+    if (other == this) return;
+    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ScanParamCfg* New(::google::protobuf::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ScanParamCfg>(arena);
+  }
+  using ::google::protobuf::Message::CopyFrom;
+  void CopyFrom(const ScanParamCfg& from);
+  using ::google::protobuf::Message::MergeFrom;
+  void MergeFrom( const ScanParamCfg& from) {
+    ScanParamCfg::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  ::size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
+  ::uint8_t* _InternalSerialize(
+      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::google::protobuf::Arena* arena);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ScanParamCfg* other);
+
+  private:
+  friend class ::google::protobuf::internal::AnyMetadata;
+  static ::absl::string_view FullMessageName() {
+    return "stream.ScanParamCfg";
+  }
+  protected:
+  explicit ScanParamCfg(::google::protobuf::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::google::protobuf::Message::ClassData*GetClassData() const final;
+
+  ::google::protobuf::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kEdgeLevelFieldNumber = 1,
+    kEdgeLevelMinFieldNumber = 2,
+    kEdgeLevelMaxFieldNumber = 3,
+    kJumpDelayFieldNumber = 4,
+    kJumpDelayMinFieldNumber = 5,
+    kJumpDelayMaxFieldNumber = 6,
+    kScanDelayFieldNumber = 7,
+    kScanDelayMinFieldNumber = 8,
+    kScanDelayMaxFieldNumber = 9,
+    kPolygonDelayFieldNumber = 10,
+    kPolygonDelayMinFieldNumber = 11,
+    kPolygonDelayMaxFieldNumber = 12,
+    kLaseroffDelayFieldNumber = 13,
+    kLaseroffDelayMinFieldNumber = 14,
+    kLaseroffDelayMaxFieldNumber = 15,
+    kLaseronDelayFieldNumber = 16,
+    kLaseronDelayMinFieldNumber = 17,
+    kLaseronDelayMaxFieldNumber = 18,
+    kMinJumpDelayFieldNumber = 19,
+    kMinJumpDelayMinFieldNumber = 20,
+    kMinJumpDelayMaxFieldNumber = 21,
+    kJumpLengthLimitFieldNumber = 22,
+    kJumpLengthLimitMinFieldNumber = 23,
+    kJumpLengthLimitMaxFieldNumber = 24,
+    kJumpSpeedFieldNumber = 25,
+    kJumpSpeedMinFieldNumber = 26,
+    kJumpSpeedMaxFieldNumber = 27,
+    kMarkSpeedFieldNumber = 28,
+    kMarkSpeedMinFieldNumber = 29,
+    kMarkSpeedMaxFieldNumber = 30,
+  };
+  // int32 edgeLevel = 1;
+  void clear_edgelevel() ;
+  ::int32_t edgelevel() const;
+  void set_edgelevel(::int32_t value);
+
+  private:
+  ::int32_t _internal_edgelevel() const;
+  void _internal_set_edgelevel(::int32_t value);
+
+  public:
+  // int32 edgeLevelMin = 2;
+  void clear_edgelevelmin() ;
+  ::int32_t edgelevelmin() const;
+  void set_edgelevelmin(::int32_t value);
+
+  private:
+  ::int32_t _internal_edgelevelmin() const;
+  void _internal_set_edgelevelmin(::int32_t value);
+
+  public:
+  // int32 edgeLevelMax = 3;
+  void clear_edgelevelmax() ;
+  ::int32_t edgelevelmax() const;
+  void set_edgelevelmax(::int32_t value);
+
+  private:
+  ::int32_t _internal_edgelevelmax() const;
+  void _internal_set_edgelevelmax(::int32_t value);
+
+  public:
+  // uint32 jumpDelay = 4;
+  void clear_jumpdelay() ;
+  ::uint32_t jumpdelay() const;
+  void set_jumpdelay(::uint32_t value);
+
+  private:
+  ::uint32_t _internal_jumpdelay() const;
+  void _internal_set_jumpdelay(::uint32_t value);
+
+  public:
+  // uint32 jumpDelayMin = 5;
+  void clear_jumpdelaymin() ;
+  ::uint32_t jumpdelaymin() const;
+  void set_jumpdelaymin(::uint32_t value);
+
+  private:
+  ::uint32_t _internal_jumpdelaymin() const;
+  void _internal_set_jumpdelaymin(::uint32_t value);
+
+  public:
+  // uint32 jumpDelayMax = 6;
+  void clear_jumpdelaymax() ;
+  ::uint32_t jumpdelaymax() const;
+  void set_jumpdelaymax(::uint32_t value);
+
+  private:
+  ::uint32_t _internal_jumpdelaymax() const;
+  void _internal_set_jumpdelaymax(::uint32_t value);
+
+  public:
+  // uint32 scanDelay = 7;
+  void clear_scandelay() ;
+  ::uint32_t scandelay() const;
+  void set_scandelay(::uint32_t value);
+
+  private:
+  ::uint32_t _internal_scandelay() const;
+  void _internal_set_scandelay(::uint32_t value);
+
+  public:
+  // uint32 scanDelayMin = 8;
+  void clear_scandelaymin() ;
+  ::uint32_t scandelaymin() const;
+  void set_scandelaymin(::uint32_t value);
+
+  private:
+  ::uint32_t _internal_scandelaymin() const;
+  void _internal_set_scandelaymin(::uint32_t value);
+
+  public:
+  // uint32 scanDelayMax = 9;
+  void clear_scandelaymax() ;
+  ::uint32_t scandelaymax() const;
+  void set_scandelaymax(::uint32_t value);
+
+  private:
+  ::uint32_t _internal_scandelaymax() const;
+  void _internal_set_scandelaymax(::uint32_t value);
+
+  public:
+  // uint32 polygonDelay = 10;
+  void clear_polygondelay() ;
+  ::uint32_t polygondelay() const;
+  void set_polygondelay(::uint32_t value);
+
+  private:
+  ::uint32_t _internal_polygondelay() const;
+  void _internal_set_polygondelay(::uint32_t value);
+
+  public:
+  // uint32 polygonDelayMin = 11;
+  void clear_polygondelaymin() ;
+  ::uint32_t polygondelaymin() const;
+  void set_polygondelaymin(::uint32_t value);
+
+  private:
+  ::uint32_t _internal_polygondelaymin() const;
+  void _internal_set_polygondelaymin(::uint32_t value);
+
+  public:
+  // uint32 polygonDelayMax = 12;
+  void clear_polygondelaymax() ;
+  ::uint32_t polygondelaymax() const;
+  void set_polygondelaymax(::uint32_t value);
+
+  private:
+  ::uint32_t _internal_polygondelaymax() const;
+  void _internal_set_polygondelaymax(::uint32_t value);
+
+  public:
+  // int64 laseroffDelay = 13;
+  void clear_laseroffdelay() ;
+  ::int64_t laseroffdelay() const;
+  void set_laseroffdelay(::int64_t value);
+
+  private:
+  ::int64_t _internal_laseroffdelay() const;
+  void _internal_set_laseroffdelay(::int64_t value);
+
+  public:
+  // int64 laseroffDelayMin = 14;
+  void clear_laseroffdelaymin() ;
+  ::int64_t laseroffdelaymin() const;
+  void set_laseroffdelaymin(::int64_t value);
+
+  private:
+  ::int64_t _internal_laseroffdelaymin() const;
+  void _internal_set_laseroffdelaymin(::int64_t value);
+
+  public:
+  // int64 laseroffDelayMax = 15;
+  void clear_laseroffdelaymax() ;
+  ::int64_t laseroffdelaymax() const;
+  void set_laseroffdelaymax(::int64_t value);
+
+  private:
+  ::int64_t _internal_laseroffdelaymax() const;
+  void _internal_set_laseroffdelaymax(::int64_t value);
+
+  public:
+  // int64 laseronDelay = 16;
+  void clear_laserondelay() ;
+  ::int64_t laserondelay() const;
+  void set_laserondelay(::int64_t value);
+
+  private:
+  ::int64_t _internal_laserondelay() const;
+  void _internal_set_laserondelay(::int64_t value);
+
+  public:
+  // int64 laseronDelayMin = 17;
+  void clear_laserondelaymin() ;
+  ::int64_t laserondelaymin() const;
+  void set_laserondelaymin(::int64_t value);
+
+  private:
+  ::int64_t _internal_laserondelaymin() const;
+  void _internal_set_laserondelaymin(::int64_t value);
+
+  public:
+  // int64 laseronDelayMax = 18;
+  void clear_laserondelaymax() ;
+  ::int64_t laserondelaymax() const;
+  void set_laserondelaymax(::int64_t value);
+
+  private:
+  ::int64_t _internal_laserondelaymax() const;
+  void _internal_set_laserondelaymax(::int64_t value);
+
+  public:
+  // uint32 minJumpDelay = 19;
+  void clear_minjumpdelay() ;
+  ::uint32_t minjumpdelay() const;
+  void set_minjumpdelay(::uint32_t value);
+
+  private:
+  ::uint32_t _internal_minjumpdelay() const;
+  void _internal_set_minjumpdelay(::uint32_t value);
+
+  public:
+  // uint32 minJumpDelayMin = 20;
+  void clear_minjumpdelaymin() ;
+  ::uint32_t minjumpdelaymin() const;
+  void set_minjumpdelaymin(::uint32_t value);
+
+  private:
+  ::uint32_t _internal_minjumpdelaymin() const;
+  void _internal_set_minjumpdelaymin(::uint32_t value);
+
+  public:
+  // uint32 minJumpDelayMax = 21;
+  void clear_minjumpdelaymax() ;
+  ::uint32_t minjumpdelaymax() const;
+  void set_minjumpdelaymax(::uint32_t value);
+
+  private:
+  ::uint32_t _internal_minjumpdelaymax() const;
+  void _internal_set_minjumpdelaymax(::uint32_t value);
+
+  public:
+  // uint32 jumpLengthLimit = 22;
+  void clear_jumplengthlimit() ;
+  ::uint32_t jumplengthlimit() const;
+  void set_jumplengthlimit(::uint32_t value);
+
+  private:
+  ::uint32_t _internal_jumplengthlimit() const;
+  void _internal_set_jumplengthlimit(::uint32_t value);
+
+  public:
+  // uint32 jumpLengthLimitMin = 23;
+  void clear_jumplengthlimitmin() ;
+  ::uint32_t jumplengthlimitmin() const;
+  void set_jumplengthlimitmin(::uint32_t value);
+
+  private:
+  ::uint32_t _internal_jumplengthlimitmin() const;
+  void _internal_set_jumplengthlimitmin(::uint32_t value);
+
+  public:
+  // uint32 jumpLengthLimitMax = 24;
+  void clear_jumplengthlimitmax() ;
+  ::uint32_t jumplengthlimitmax() const;
+  void set_jumplengthlimitmax(::uint32_t value);
+
+  private:
+  ::uint32_t _internal_jumplengthlimitmax() const;
+  void _internal_set_jumplengthlimitmax(::uint32_t value);
+
+  public:
+  // double jumpSpeed = 25;
+  void clear_jumpspeed() ;
+  double jumpspeed() const;
+  void set_jumpspeed(double value);
+
+  private:
+  double _internal_jumpspeed() const;
+  void _internal_set_jumpspeed(double value);
+
+  public:
+  // double jumpSpeedMin = 26;
+  void clear_jumpspeedmin() ;
+  double jumpspeedmin() const;
+  void set_jumpspeedmin(double value);
+
+  private:
+  double _internal_jumpspeedmin() const;
+  void _internal_set_jumpspeedmin(double value);
+
+  public:
+  // double jumpSpeedMax = 27;
+  void clear_jumpspeedmax() ;
+  double jumpspeedmax() const;
+  void set_jumpspeedmax(double value);
+
+  private:
+  double _internal_jumpspeedmax() const;
+  void _internal_set_jumpspeedmax(double value);
+
+  public:
+  // double markSpeed = 28;
+  void clear_markspeed() ;
+  double markspeed() const;
+  void set_markspeed(double value);
+
+  private:
+  double _internal_markspeed() const;
+  void _internal_set_markspeed(double value);
+
+  public:
+  // double markSpeedMin = 29;
+  void clear_markspeedmin() ;
+  double markspeedmin() const;
+  void set_markspeedmin(double value);
+
+  private:
+  double _internal_markspeedmin() const;
+  void _internal_set_markspeedmin(double value);
+
+  public:
+  // double markSpeedMax = 30;
+  void clear_markspeedmax() ;
+  double markspeedmax() const;
+  void set_markspeedmax(double value);
+
+  private:
+  double _internal_markspeedmax() const;
+  void _internal_set_markspeedmax(double value);
+
+  public:
+  // @@protoc_insertion_point(class_scope:stream.ScanParamCfg)
+ private:
+  class _Internal;
+
+  friend class ::google::protobuf::internal::TcParser;
+  static const ::google::protobuf::internal::TcParseTable<5, 30, 0, 0, 2> _table_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::int32_t edgelevel_;
+    ::int32_t edgelevelmin_;
+    ::int32_t edgelevelmax_;
+    ::uint32_t jumpdelay_;
+    ::uint32_t jumpdelaymin_;
+    ::uint32_t jumpdelaymax_;
+    ::uint32_t scandelay_;
+    ::uint32_t scandelaymin_;
+    ::uint32_t scandelaymax_;
+    ::uint32_t polygondelay_;
+    ::uint32_t polygondelaymin_;
+    ::uint32_t polygondelaymax_;
+    ::int64_t laseroffdelay_;
+    ::int64_t laseroffdelaymin_;
+    ::int64_t laseroffdelaymax_;
+    ::int64_t laserondelay_;
+    ::int64_t laserondelaymin_;
+    ::int64_t laserondelaymax_;
+    ::uint32_t minjumpdelay_;
+    ::uint32_t minjumpdelaymin_;
+    ::uint32_t minjumpdelaymax_;
+    ::uint32_t jumplengthlimit_;
+    ::uint32_t jumplengthlimitmin_;
+    ::uint32_t jumplengthlimitmax_;
+    double jumpspeed_;
+    double jumpspeedmin_;
+    double jumpspeedmax_;
+    double markspeed_;
+    double markspeedmin_;
+    double markspeedmax_;
+    mutable ::google::protobuf::internal::CachedSize _cached_size_;
+    PROTOBUF_TSAN_DECLARE_MEMBER
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_stream_2eproto;
+};// -------------------------------------------------------------------
+
+class CorrectParamCfg final :
+    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:stream.CorrectParamCfg) */ {
+ public:
+  inline CorrectParamCfg() : CorrectParamCfg(nullptr) {}
+  ~CorrectParamCfg() override;
+  template<typename = void>
+  explicit PROTOBUF_CONSTEXPR CorrectParamCfg(::google::protobuf::internal::ConstantInitialized);
+
+  CorrectParamCfg(const CorrectParamCfg& from);
+  CorrectParamCfg(CorrectParamCfg&& from) noexcept
+    : CorrectParamCfg() {
+    *this = ::std::move(from);
+  }
+
+  inline CorrectParamCfg& operator=(const CorrectParamCfg& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline CorrectParamCfg& operator=(CorrectParamCfg&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
+  }
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::google::protobuf::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::google::protobuf::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const CorrectParamCfg& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const CorrectParamCfg* internal_default_instance() {
+    return reinterpret_cast<const CorrectParamCfg*>(
+               &_CorrectParamCfg_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    16;
+
+  friend void swap(CorrectParamCfg& a, CorrectParamCfg& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(CorrectParamCfg* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::google::protobuf::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(CorrectParamCfg* other) {
+    if (other == this) return;
+    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  CorrectParamCfg* New(::google::protobuf::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<CorrectParamCfg>(arena);
+  }
+  using ::google::protobuf::Message::CopyFrom;
+  void CopyFrom(const CorrectParamCfg& from);
+  using ::google::protobuf::Message::MergeFrom;
+  void MergeFrom( const CorrectParamCfg& from) {
+    CorrectParamCfg::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  ::size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
+  ::uint8_t* _InternalSerialize(
+      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::google::protobuf::Arena* arena);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(CorrectParamCfg* other);
+
+  private:
+  friend class ::google::protobuf::internal::AnyMetadata;
+  static ::absl::string_view FullMessageName() {
+    return "stream.CorrectParamCfg";
+  }
+  protected:
+  explicit CorrectParamCfg(::google::protobuf::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::google::protobuf::Message::ClassData*GetClassData() const final;
+
+  ::google::protobuf::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kXmeasureMinFieldNumber = 1,
+    kXmeasureMaxFieldNumber = 2,
+    kYmeasureMinFieldNumber = 3,
+    kYmeasureMaxFieldNumber = 4,
+    kXposfixFieldNumber = 5,
+    kYposfixFieldNumber = 6,
+    kScanAngleFieldNumber = 7,
+    kScanAngleMinFieldNumber = 8,
+    kScanAngleMaxFieldNumber = 9,
+    kFixAngleFieldNumber = 10,
+    kFixAngleMinFieldNumber = 11,
+    kFixAngleMaxFieldNumber = 12,
+    kXcorrectFieldNumber = 13,
+    kYcorrectFieldNumber = 14,
+    kXcorrectMinFieldNumber = 15,
+    kXcorrectMaxFieldNumber = 16,
+    kYcorrectMinFieldNumber = 17,
+    kYcorrectMaxFieldNumber = 18,
+    kRealXOffsetFieldNumber = 19,
+    kRealYOffsetFieldNumber = 20,
+    kFactorKFieldNumber = 21,
+    kDefocusRatioFieldNumber = 24,
+    kDefocusRatioMinFieldNumber = 25,
+    kDefocusRatioMaxFieldNumber = 26,
+    kIsCorrectFile3DFieldNumber = 22,
+    kIsDynamicFocusFieldNumber = 23,
+  };
+  // double xmeasureMin = 1;
+  void clear_xmeasuremin() ;
+  double xmeasuremin() const;
+  void set_xmeasuremin(double value);
+
+  private:
+  double _internal_xmeasuremin() const;
+  void _internal_set_xmeasuremin(double value);
+
+  public:
+  // double xmeasureMax = 2;
+  void clear_xmeasuremax() ;
+  double xmeasuremax() const;
+  void set_xmeasuremax(double value);
+
+  private:
+  double _internal_xmeasuremax() const;
+  void _internal_set_xmeasuremax(double value);
+
+  public:
+  // double ymeasureMin = 3;
+  void clear_ymeasuremin() ;
+  double ymeasuremin() const;
+  void set_ymeasuremin(double value);
+
+  private:
+  double _internal_ymeasuremin() const;
+  void _internal_set_ymeasuremin(double value);
+
+  public:
+  // double ymeasureMax = 4;
+  void clear_ymeasuremax() ;
+  double ymeasuremax() const;
+  void set_ymeasuremax(double value);
+
+  private:
+  double _internal_ymeasuremax() const;
+  void _internal_set_ymeasuremax(double value);
+
+  public:
+  // double xposfix = 5;
+  void clear_xposfix() ;
+  double xposfix() const;
+  void set_xposfix(double value);
+
+  private:
+  double _internal_xposfix() const;
+  void _internal_set_xposfix(double value);
+
+  public:
+  // double yposfix = 6;
+  void clear_yposfix() ;
+  double yposfix() const;
+  void set_yposfix(double value);
+
+  private:
+  double _internal_yposfix() const;
+  void _internal_set_yposfix(double value);
+
+  public:
+  // double scanAngle = 7;
+  void clear_scanangle() ;
+  double scanangle() const;
+  void set_scanangle(double value);
+
+  private:
+  double _internal_scanangle() const;
+  void _internal_set_scanangle(double value);
+
+  public:
+  // double scanAngleMin = 8;
+  void clear_scananglemin() ;
+  double scananglemin() const;
+  void set_scananglemin(double value);
+
+  private:
+  double _internal_scananglemin() const;
+  void _internal_set_scananglemin(double value);
+
+  public:
+  // double scanAngleMax = 9;
+  void clear_scananglemax() ;
+  double scananglemax() const;
+  void set_scananglemax(double value);
+
+  private:
+  double _internal_scananglemax() const;
+  void _internal_set_scananglemax(double value);
+
+  public:
+  // double fixAngle = 10;
+  void clear_fixangle() ;
+  double fixangle() const;
+  void set_fixangle(double value);
+
+  private:
+  double _internal_fixangle() const;
+  void _internal_set_fixangle(double value);
+
+  public:
+  // double fixAngleMin = 11;
+  void clear_fixanglemin() ;
+  double fixanglemin() const;
+  void set_fixanglemin(double value);
+
+  private:
+  double _internal_fixanglemin() const;
+  void _internal_set_fixanglemin(double value);
+
+  public:
+  // double fixAngleMax = 12;
+  void clear_fixanglemax() ;
+  double fixanglemax() const;
+  void set_fixanglemax(double value);
+
+  private:
+  double _internal_fixanglemax() const;
+  void _internal_set_fixanglemax(double value);
+
+  public:
+  // double xcorrect = 13;
+  void clear_xcorrect() ;
+  double xcorrect() const;
+  void set_xcorrect(double value);
+
+  private:
+  double _internal_xcorrect() const;
+  void _internal_set_xcorrect(double value);
+
+  public:
+  // double ycorrect = 14;
+  void clear_ycorrect() ;
+  double ycorrect() const;
+  void set_ycorrect(double value);
+
+  private:
+  double _internal_ycorrect() const;
+  void _internal_set_ycorrect(double value);
+
+  public:
+  // double xcorrectMin = 15;
+  void clear_xcorrectmin() ;
+  double xcorrectmin() const;
+  void set_xcorrectmin(double value);
+
+  private:
+  double _internal_xcorrectmin() const;
+  void _internal_set_xcorrectmin(double value);
+
+  public:
+  // double xcorrectMax = 16;
+  void clear_xcorrectmax() ;
+  double xcorrectmax() const;
+  void set_xcorrectmax(double value);
+
+  private:
+  double _internal_xcorrectmax() const;
+  void _internal_set_xcorrectmax(double value);
+
+  public:
+  // double ycorrectMin = 17;
+  void clear_ycorrectmin() ;
+  double ycorrectmin() const;
+  void set_ycorrectmin(double value);
+
+  private:
+  double _internal_ycorrectmin() const;
+  void _internal_set_ycorrectmin(double value);
+
+  public:
+  // double ycorrectMax = 18;
+  void clear_ycorrectmax() ;
+  double ycorrectmax() const;
+  void set_ycorrectmax(double value);
+
+  private:
+  double _internal_ycorrectmax() const;
+  void _internal_set_ycorrectmax(double value);
+
+  public:
+  // double realXOffset = 19;
+  void clear_realxoffset() ;
+  double realxoffset() const;
+  void set_realxoffset(double value);
+
+  private:
+  double _internal_realxoffset() const;
+  void _internal_set_realxoffset(double value);
+
+  public:
+  // double realYOffset = 20;
+  void clear_realyoffset() ;
+  double realyoffset() const;
+  void set_realyoffset(double value);
+
+  private:
+  double _internal_realyoffset() const;
+  void _internal_set_realyoffset(double value);
+
+  public:
+  // double factorK = 21;
+  void clear_factork() ;
+  double factork() const;
+  void set_factork(double value);
+
+  private:
+  double _internal_factork() const;
+  void _internal_set_factork(double value);
+
+  public:
+  // double defocusRatio = 24;
+  void clear_defocusratio() ;
+  double defocusratio() const;
+  void set_defocusratio(double value);
+
+  private:
+  double _internal_defocusratio() const;
+  void _internal_set_defocusratio(double value);
+
+  public:
+  // double defocusRatioMin = 25;
+  void clear_defocusratiomin() ;
+  double defocusratiomin() const;
+  void set_defocusratiomin(double value);
+
+  private:
+  double _internal_defocusratiomin() const;
+  void _internal_set_defocusratiomin(double value);
+
+  public:
+  // double defocusRatioMax = 26;
+  void clear_defocusratiomax() ;
+  double defocusratiomax() const;
+  void set_defocusratiomax(double value);
+
+  private:
+  double _internal_defocusratiomax() const;
+  void _internal_set_defocusratiomax(double value);
+
+  public:
+  // bool isCorrectFile3D = 22;
+  void clear_iscorrectfile3d() ;
+  bool iscorrectfile3d() const;
+  void set_iscorrectfile3d(bool value);
+
+  private:
+  bool _internal_iscorrectfile3d() const;
+  void _internal_set_iscorrectfile3d(bool value);
+
+  public:
+  // bool isDynamicFocus = 23;
+  void clear_isdynamicfocus() ;
+  bool isdynamicfocus() const;
+  void set_isdynamicfocus(bool value);
+
+  private:
+  bool _internal_isdynamicfocus() const;
+  void _internal_set_isdynamicfocus(bool value);
+
+  public:
+  // @@protoc_insertion_point(class_scope:stream.CorrectParamCfg)
+ private:
+  class _Internal;
+
+  friend class ::google::protobuf::internal::TcParser;
+  static const ::google::protobuf::internal::TcParseTable<5, 26, 0, 0, 2> _table_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    double xmeasuremin_;
+    double xmeasuremax_;
+    double ymeasuremin_;
+    double ymeasuremax_;
+    double xposfix_;
+    double yposfix_;
+    double scanangle_;
+    double scananglemin_;
+    double scananglemax_;
+    double fixangle_;
+    double fixanglemin_;
+    double fixanglemax_;
+    double xcorrect_;
+    double ycorrect_;
+    double xcorrectmin_;
+    double xcorrectmax_;
+    double ycorrectmin_;
+    double ycorrectmax_;
+    double realxoffset_;
+    double realyoffset_;
+    double factork_;
+    double defocusratio_;
+    double defocusratiomin_;
+    double defocusratiomax_;
+    bool iscorrectfile3d_;
+    bool isdynamicfocus_;
+    mutable ::google::protobuf::internal::CachedSize _cached_size_;
+    PROTOBUF_TSAN_DECLARE_MEMBER
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_stream_2eproto;
+};// -------------------------------------------------------------------
+
+class ScanTestCfg final :
+    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:stream.ScanTestCfg) */ {
+ public:
+  inline ScanTestCfg() : ScanTestCfg(nullptr) {}
+  ~ScanTestCfg() override;
+  template<typename = void>
+  explicit PROTOBUF_CONSTEXPR ScanTestCfg(::google::protobuf::internal::ConstantInitialized);
+
+  ScanTestCfg(const ScanTestCfg& from);
+  ScanTestCfg(ScanTestCfg&& from) noexcept
+    : ScanTestCfg() {
+    *this = ::std::move(from);
+  }
+
+  inline ScanTestCfg& operator=(const ScanTestCfg& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ScanTestCfg& operator=(ScanTestCfg&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
+  }
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::google::protobuf::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::google::protobuf::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ScanTestCfg& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ScanTestCfg* internal_default_instance() {
+    return reinterpret_cast<const ScanTestCfg*>(
+               &_ScanTestCfg_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    17;
+
+  friend void swap(ScanTestCfg& a, ScanTestCfg& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ScanTestCfg* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::google::protobuf::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ScanTestCfg* other) {
+    if (other == this) return;
+    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ScanTestCfg* New(::google::protobuf::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ScanTestCfg>(arena);
+  }
+  using ::google::protobuf::Message::CopyFrom;
+  void CopyFrom(const ScanTestCfg& from);
+  using ::google::protobuf::Message::MergeFrom;
+  void MergeFrom( const ScanTestCfg& from) {
+    ScanTestCfg::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  ::size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
+  ::uint8_t* _InternalSerialize(
+      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::google::protobuf::Arena* arena);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ScanTestCfg* other);
+
+  private:
+  friend class ::google::protobuf::internal::AnyMetadata;
+  static ::absl::string_view FullMessageName() {
+    return "stream.ScanTestCfg";
+  }
+  protected:
+  explicit ScanTestCfg(::google::protobuf::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::google::protobuf::Message::ClassData*GetClassData() const final;
+
+  ::google::protobuf::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDebugShapeFieldNumber = 1,
+    kShapeSizeFieldNumber = 2,
+    kShapeSizeMinFieldNumber = 3,
+    kShapeSizeMaxFieldNumber = 4,
+    kLaserPowerFieldNumber = 5,
+    kLaserPowerMinFieldNumber = 6,
+    kDefocusFieldNumber = 8,
+    kDefocusMinFieldNumber = 9,
+    kDefocusMaxFieldNumber = 10,
+    kLaserPowerMaxFieldNumber = 7,
+    kIsCycleFieldNumber = 11,
+    kIsAutoHeatingScannerFieldNumber = 15,
+    kCrossXFieldNumber = 12,
+    kCrossYFieldNumber = 13,
+    kZDistanceFieldNumber = 14,
+    kAutoHeatingScannerMinutesFieldNumber = 16,
+    kAutoHeatingScannerSizeFieldNumber = 17,
+    kAutoHeatingScannerSpeedFieldNumber = 18,
+    kMarkTestStartXFieldNumber = 19,
+    kMarkTestStartYFieldNumber = 20,
+    kMarkTestEndXFieldNumber = 21,
+    kMarkTestEndYFieldNumber = 22,
+  };
+  // int32 debugShape = 1;
+  void clear_debugshape() ;
+  ::int32_t debugshape() const;
+  void set_debugshape(::int32_t value);
+
+  private:
+  ::int32_t _internal_debugshape() const;
+  void _internal_set_debugshape(::int32_t value);
+
+  public:
+  // int32 shapeSize = 2;
+  void clear_shapesize() ;
+  ::int32_t shapesize() const;
+  void set_shapesize(::int32_t value);
+
+  private:
+  ::int32_t _internal_shapesize() const;
+  void _internal_set_shapesize(::int32_t value);
+
+  public:
+  // int32 shapeSizeMin = 3;
+  void clear_shapesizemin() ;
+  ::int32_t shapesizemin() const;
+  void set_shapesizemin(::int32_t value);
+
+  private:
+  ::int32_t _internal_shapesizemin() const;
+  void _internal_set_shapesizemin(::int32_t value);
+
+  public:
+  // int32 shape_size_max = 4;
+  void clear_shape_size_max() ;
+  ::int32_t shape_size_max() const;
+  void set_shape_size_max(::int32_t value);
+
+  private:
+  ::int32_t _internal_shape_size_max() const;
+  void _internal_set_shape_size_max(::int32_t value);
+
+  public:
+  // int32 laser_power = 5;
+  void clear_laser_power() ;
+  ::int32_t laser_power() const;
+  void set_laser_power(::int32_t value);
+
+  private:
+  ::int32_t _internal_laser_power() const;
+  void _internal_set_laser_power(::int32_t value);
+
+  public:
+  // int32 laser_power_min = 6;
+  void clear_laser_power_min() ;
+  ::int32_t laser_power_min() const;
+  void set_laser_power_min(::int32_t value);
+
+  private:
+  ::int32_t _internal_laser_power_min() const;
+  void _internal_set_laser_power_min(::int32_t value);
+
+  public:
+  // double defocus = 8;
+  void clear_defocus() ;
+  double defocus() const;
+  void set_defocus(double value);
+
+  private:
+  double _internal_defocus() const;
+  void _internal_set_defocus(double value);
+
+  public:
+  // double defocus_min = 9;
+  void clear_defocus_min() ;
+  double defocus_min() const;
+  void set_defocus_min(double value);
+
+  private:
+  double _internal_defocus_min() const;
+  void _internal_set_defocus_min(double value);
+
+  public:
+  // double defocus_max = 10;
+  void clear_defocus_max() ;
+  double defocus_max() const;
+  void set_defocus_max(double value);
+
+  private:
+  double _internal_defocus_max() const;
+  void _internal_set_defocus_max(double value);
+
+  public:
+  // int32 laser_power_max = 7;
+  void clear_laser_power_max() ;
+  ::int32_t laser_power_max() const;
+  void set_laser_power_max(::int32_t value);
+
+  private:
+  ::int32_t _internal_laser_power_max() const;
+  void _internal_set_laser_power_max(::int32_t value);
+
+  public:
+  // bool is_cycle = 11;
+  void clear_is_cycle() ;
+  bool is_cycle() const;
+  void set_is_cycle(bool value);
+
+  private:
+  bool _internal_is_cycle() const;
+  void _internal_set_is_cycle(bool value);
+
+  public:
+  // bool isAutoHeatingScanner = 15;
+  void clear_isautoheatingscanner() ;
+  bool isautoheatingscanner() const;
+  void set_isautoheatingscanner(bool value);
+
+  private:
+  bool _internal_isautoheatingscanner() const;
+  void _internal_set_isautoheatingscanner(bool value);
+
+  public:
+  // double cross_x = 12;
+  void clear_cross_x() ;
+  double cross_x() const;
+  void set_cross_x(double value);
+
+  private:
+  double _internal_cross_x() const;
+  void _internal_set_cross_x(double value);
+
+  public:
+  // double cross_y = 13;
+  void clear_cross_y() ;
+  double cross_y() const;
+  void set_cross_y(double value);
+
+  private:
+  double _internal_cross_y() const;
+  void _internal_set_cross_y(double value);
+
+  public:
+  // double z_distance = 14;
+  void clear_z_distance() ;
+  double z_distance() const;
+  void set_z_distance(double value);
+
+  private:
+  double _internal_z_distance() const;
+  void _internal_set_z_distance(double value);
+
+  public:
+  // uint32 autoHeatingScannerMinutes = 16;
+  void clear_autoheatingscannerminutes() ;
+  ::uint32_t autoheatingscannerminutes() const;
+  void set_autoheatingscannerminutes(::uint32_t value);
+
+  private:
+  ::uint32_t _internal_autoheatingscannerminutes() const;
+  void _internal_set_autoheatingscannerminutes(::uint32_t value);
+
+  public:
+  // uint32 autoHeatingScannerSize = 17;
+  void clear_autoheatingscannersize() ;
+  ::uint32_t autoheatingscannersize() const;
+  void set_autoheatingscannersize(::uint32_t value);
+
+  private:
+  ::uint32_t _internal_autoheatingscannersize() const;
+  void _internal_set_autoheatingscannersize(::uint32_t value);
+
+  public:
+  // double autoHeatingScannerSpeed = 18;
+  void clear_autoheatingscannerspeed() ;
+  double autoheatingscannerspeed() const;
+  void set_autoheatingscannerspeed(double value);
+
+  private:
+  double _internal_autoheatingscannerspeed() const;
+  void _internal_set_autoheatingscannerspeed(double value);
+
+  public:
+  // double mark_test_start_x = 19;
+  void clear_mark_test_start_x() ;
+  double mark_test_start_x() const;
+  void set_mark_test_start_x(double value);
+
+  private:
+  double _internal_mark_test_start_x() const;
+  void _internal_set_mark_test_start_x(double value);
+
+  public:
+  // double mark_test_start_y = 20;
+  void clear_mark_test_start_y() ;
+  double mark_test_start_y() const;
+  void set_mark_test_start_y(double value);
+
+  private:
+  double _internal_mark_test_start_y() const;
+  void _internal_set_mark_test_start_y(double value);
+
+  public:
+  // double mark_test_end_x = 21;
+  void clear_mark_test_end_x() ;
+  double mark_test_end_x() const;
+  void set_mark_test_end_x(double value);
+
+  private:
+  double _internal_mark_test_end_x() const;
+  void _internal_set_mark_test_end_x(double value);
+
+  public:
+  // double mark_test_end_y = 22;
+  void clear_mark_test_end_y() ;
+  double mark_test_end_y() const;
+  void set_mark_test_end_y(double value);
+
+  private:
+  double _internal_mark_test_end_y() const;
+  void _internal_set_mark_test_end_y(double value);
+
+  public:
+  // @@protoc_insertion_point(class_scope:stream.ScanTestCfg)
+ private:
+  class _Internal;
+
+  friend class ::google::protobuf::internal::TcParser;
+  static const ::google::protobuf::internal::TcParseTable<5, 22, 0, 0, 2> _table_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::int32_t debugshape_;
+    ::int32_t shapesize_;
+    ::int32_t shapesizemin_;
+    ::int32_t shape_size_max_;
+    ::int32_t laser_power_;
+    ::int32_t laser_power_min_;
+    double defocus_;
+    double defocus_min_;
+    double defocus_max_;
+    ::int32_t laser_power_max_;
+    bool is_cycle_;
+    bool isautoheatingscanner_;
+    double cross_x_;
+    double cross_y_;
+    double z_distance_;
+    ::uint32_t autoheatingscannerminutes_;
+    ::uint32_t autoheatingscannersize_;
+    double autoheatingscannerspeed_;
+    double mark_test_start_x_;
+    double mark_test_start_y_;
+    double mark_test_end_x_;
+    double mark_test_end_y_;
+    mutable ::google::protobuf::internal::CachedSize _cached_size_;
+    PROTOBUF_TSAN_DECLARE_MEMBER
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_stream_2eproto;
+};// -------------------------------------------------------------------
+
+class SkyWritingCfg final :
+    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:stream.SkyWritingCfg) */ {
+ public:
+  inline SkyWritingCfg() : SkyWritingCfg(nullptr) {}
+  ~SkyWritingCfg() override;
+  template<typename = void>
+  explicit PROTOBUF_CONSTEXPR SkyWritingCfg(::google::protobuf::internal::ConstantInitialized);
+
+  SkyWritingCfg(const SkyWritingCfg& from);
+  SkyWritingCfg(SkyWritingCfg&& from) noexcept
+    : SkyWritingCfg() {
+    *this = ::std::move(from);
+  }
+
+  inline SkyWritingCfg& operator=(const SkyWritingCfg& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SkyWritingCfg& operator=(SkyWritingCfg&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
+  }
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::google::protobuf::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::google::protobuf::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SkyWritingCfg& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SkyWritingCfg* internal_default_instance() {
+    return reinterpret_cast<const SkyWritingCfg*>(
+               &_SkyWritingCfg_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    18;
+
+  friend void swap(SkyWritingCfg& a, SkyWritingCfg& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SkyWritingCfg* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::google::protobuf::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SkyWritingCfg* other) {
+    if (other == this) return;
+    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SkyWritingCfg* New(::google::protobuf::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SkyWritingCfg>(arena);
+  }
+  using ::google::protobuf::Message::CopyFrom;
+  void CopyFrom(const SkyWritingCfg& from);
+  using ::google::protobuf::Message::MergeFrom;
+  void MergeFrom( const SkyWritingCfg& from) {
+    SkyWritingCfg::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  ::size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
+  ::uint8_t* _InternalSerialize(
+      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::google::protobuf::Arena* arena);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SkyWritingCfg* other);
+
+  private:
+  friend class ::google::protobuf::internal::AnyMetadata;
+  static ::absl::string_view FullMessageName() {
+    return "stream.SkyWritingCfg";
+  }
+  protected:
+  explicit SkyWritingCfg(::google::protobuf::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::google::protobuf::Message::ClassData*GetClassData() const final;
+
+  ::google::protobuf::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTimelagFieldNumber = 2,
+    kTimelagMinFieldNumber = 3,
+    kTimelagMaxFieldNumber = 4,
+    kIsEnableFieldNumber = 1,
+    kNprevFieldNumber = 8,
+    kLaserOnShiftFieldNumber = 5,
+    kLaserOnShiftMinFieldNumber = 6,
+    kLaserOnShiftMaxFieldNumber = 7,
+    kNprevMinFieldNumber = 9,
+    kNprevMaxFieldNumber = 10,
+    kNpostFieldNumber = 11,
+    kNpostMinFieldNumber = 12,
+    kNpostMaxFieldNumber = 13,
+    kModeFieldNumber = 14,
+    kLimiteFieldNumber = 15,
+    kLimiteMinFieldNumber = 16,
+    kLimiteMaxFieldNumber = 17,
+  };
+  // double timelag = 2;
+  void clear_timelag() ;
+  double timelag() const;
+  void set_timelag(double value);
+
+  private:
+  double _internal_timelag() const;
+  void _internal_set_timelag(double value);
+
+  public:
+  // double timelagMin = 3;
+  void clear_timelagmin() ;
+  double timelagmin() const;
+  void set_timelagmin(double value);
+
+  private:
+  double _internal_timelagmin() const;
+  void _internal_set_timelagmin(double value);
+
+  public:
+  // double timelagMax = 4;
+  void clear_timelagmax() ;
+  double timelagmax() const;
+  void set_timelagmax(double value);
+
+  private:
+  double _internal_timelagmax() const;
+  void _internal_set_timelagmax(double value);
+
+  public:
+  // bool isEnable = 1;
+  void clear_isenable() ;
+  bool isenable() const;
+  void set_isenable(bool value);
+
+  private:
+  bool _internal_isenable() const;
+  void _internal_set_isenable(bool value);
+
+  public:
+  // uint32 nprev = 8;
+  void clear_nprev() ;
+  ::uint32_t nprev() const;
+  void set_nprev(::uint32_t value);
+
+  private:
+  ::uint32_t _internal_nprev() const;
+  void _internal_set_nprev(::uint32_t value);
+
+  public:
+  // int64 laserOnShift = 5;
+  void clear_laseronshift() ;
+  ::int64_t laseronshift() const;
+  void set_laseronshift(::int64_t value);
+
+  private:
+  ::int64_t _internal_laseronshift() const;
+  void _internal_set_laseronshift(::int64_t value);
+
+  public:
+  // int64 laserOnShiftMin = 6;
+  void clear_laseronshiftmin() ;
+  ::int64_t laseronshiftmin() const;
+  void set_laseronshiftmin(::int64_t value);
+
+  private:
+  ::int64_t _internal_laseronshiftmin() const;
+  void _internal_set_laseronshiftmin(::int64_t value);
+
+  public:
+  // int64 laserOnShiftMax = 7;
+  void clear_laseronshiftmax() ;
+  ::int64_t laseronshiftmax() const;
+  void set_laseronshiftmax(::int64_t value);
+
+  private:
+  ::int64_t _internal_laseronshiftmax() const;
+  void _internal_set_laseronshiftmax(::int64_t value);
+
+  public:
+  // uint32 nprevMin = 9;
+  void clear_nprevmin() ;
+  ::uint32_t nprevmin() const;
+  void set_nprevmin(::uint32_t value);
+
+  private:
+  ::uint32_t _internal_nprevmin() const;
+  void _internal_set_nprevmin(::uint32_t value);
+
+  public:
+  // uint32 nprevMax = 10;
+  void clear_nprevmax() ;
+  ::uint32_t nprevmax() const;
+  void set_nprevmax(::uint32_t value);
+
+  private:
+  ::uint32_t _internal_nprevmax() const;
+  void _internal_set_nprevmax(::uint32_t value);
+
+  public:
+  // uint32 npost = 11;
+  void clear_npost() ;
+  ::uint32_t npost() const;
+  void set_npost(::uint32_t value);
+
+  private:
+  ::uint32_t _internal_npost() const;
+  void _internal_set_npost(::uint32_t value);
+
+  public:
+  // uint32 npostMin = 12;
+  void clear_npostmin() ;
+  ::uint32_t npostmin() const;
+  void set_npostmin(::uint32_t value);
+
+  private:
+  ::uint32_t _internal_npostmin() const;
+  void _internal_set_npostmin(::uint32_t value);
+
+  public:
+  // uint32 npostMax = 13;
+  void clear_npostmax() ;
+  ::uint32_t npostmax() const;
+  void set_npostmax(::uint32_t value);
+
+  private:
+  ::uint32_t _internal_npostmax() const;
+  void _internal_set_npostmax(::uint32_t value);
+
+  public:
+  // int32 mode = 14;
+  void clear_mode() ;
+  ::int32_t mode() const;
+  void set_mode(::int32_t value);
+
+  private:
+  ::int32_t _internal_mode() const;
+  void _internal_set_mode(::int32_t value);
+
+  public:
+  // double limite = 15;
+  void clear_limite() ;
+  double limite() const;
+  void set_limite(double value);
+
+  private:
+  double _internal_limite() const;
+  void _internal_set_limite(double value);
+
+  public:
+  // double limiteMin = 16;
+  void clear_limitemin() ;
+  double limitemin() const;
+  void set_limitemin(double value);
+
+  private:
+  double _internal_limitemin() const;
+  void _internal_set_limitemin(double value);
+
+  public:
+  // double limiteMax = 17;
+  void clear_limitemax() ;
+  double limitemax() const;
+  void set_limitemax(double value);
+
+  private:
+  double _internal_limitemax() const;
+  void _internal_set_limitemax(double value);
+
+  public:
+  // @@protoc_insertion_point(class_scope:stream.SkyWritingCfg)
+ private:
+  class _Internal;
+
+  friend class ::google::protobuf::internal::TcParser;
+  static const ::google::protobuf::internal::TcParseTable<5, 17, 0, 0, 2> _table_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    double timelag_;
+    double timelagmin_;
+    double timelagmax_;
+    bool isenable_;
+    ::uint32_t nprev_;
+    ::int64_t laseronshift_;
+    ::int64_t laseronshiftmin_;
+    ::int64_t laseronshiftmax_;
+    ::uint32_t nprevmin_;
+    ::uint32_t nprevmax_;
+    ::uint32_t npost_;
+    ::uint32_t npostmin_;
+    ::uint32_t npostmax_;
+    ::int32_t mode_;
+    double limite_;
+    double limitemin_;
+    double limitemax_;
+    mutable ::google::protobuf::internal::CachedSize _cached_size_;
+    PROTOBUF_TSAN_DECLARE_MEMBER
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_stream_2eproto;
+};// -------------------------------------------------------------------
+
+class PowerCompensate final :
+    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:stream.PowerCompensate) */ {
+ public:
+  inline PowerCompensate() : PowerCompensate(nullptr) {}
+  ~PowerCompensate() override;
+  template<typename = void>
+  explicit PROTOBUF_CONSTEXPR PowerCompensate(::google::protobuf::internal::ConstantInitialized);
+
+  PowerCompensate(const PowerCompensate& from);
+  PowerCompensate(PowerCompensate&& from) noexcept
+    : PowerCompensate() {
+    *this = ::std::move(from);
+  }
+
+  inline PowerCompensate& operator=(const PowerCompensate& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline PowerCompensate& operator=(PowerCompensate&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
+  }
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::google::protobuf::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::google::protobuf::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const PowerCompensate& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const PowerCompensate* internal_default_instance() {
+    return reinterpret_cast<const PowerCompensate*>(
+               &_PowerCompensate_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    19;
+
+  friend void swap(PowerCompensate& a, PowerCompensate& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(PowerCompensate* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::google::protobuf::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(PowerCompensate* other) {
+    if (other == this) return;
+    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  PowerCompensate* New(::google::protobuf::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<PowerCompensate>(arena);
+  }
+  using ::google::protobuf::Message::CopyFrom;
+  void CopyFrom(const PowerCompensate& from);
+  using ::google::protobuf::Message::MergeFrom;
+  void MergeFrom( const PowerCompensate& from) {
+    PowerCompensate::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  ::size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
+  ::uint8_t* _InternalSerialize(
+      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::google::protobuf::Arena* arena);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(PowerCompensate* other);
+
+  private:
+  friend class ::google::protobuf::internal::AnyMetadata;
+  static ::absl::string_view FullMessageName() {
+    return "stream.PowerCompensate";
+  }
+  protected:
+  explicit PowerCompensate(::google::protobuf::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::google::protobuf::Message::ClassData*GetClassData() const final;
+
+  ::google::protobuf::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kCnoFieldNumber = 1,
+    kPercentFieldNumber = 2,
+    kValueFieldNumber = 3,
+    kValueMinFieldNumber = 4,
+    kValueMaxFieldNumber = 5,
+  };
+  // int32 cno = 1;
+  void clear_cno() ;
+  ::int32_t cno() const;
+  void set_cno(::int32_t value);
+
+  private:
+  ::int32_t _internal_cno() const;
+  void _internal_set_cno(::int32_t value);
+
+  public:
+  // int32 percent = 2;
+  void clear_percent() ;
+  ::int32_t percent() const;
+  void set_percent(::int32_t value);
+
+  private:
+  ::int32_t _internal_percent() const;
+  void _internal_set_percent(::int32_t value);
+
+  public:
+  // float value = 3;
+  void clear_value() ;
+  float value() const;
+  void set_value(float value);
+
+  private:
+  float _internal_value() const;
+  void _internal_set_value(float value);
+
+  public:
+  // float value_min = 4;
+  void clear_value_min() ;
+  float value_min() const;
+  void set_value_min(float value);
+
+  private:
+  float _internal_value_min() const;
+  void _internal_set_value_min(float value);
+
+  public:
+  // float value_max = 5;
+  void clear_value_max() ;
+  float value_max() const;
+  void set_value_max(float value);
+
+  private:
+  float _internal_value_max() const;
+  void _internal_set_value_max(float value);
+
+  public:
+  // @@protoc_insertion_point(class_scope:stream.PowerCompensate)
+ private:
+  class _Internal;
+
+  friend class ::google::protobuf::internal::TcParser;
+  static const ::google::protobuf::internal::TcParseTable<3, 5, 0, 0, 2> _table_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::int32_t cno_;
+    ::int32_t percent_;
+    float value_;
+    float value_min_;
+    float value_max_;
+    mutable ::google::protobuf::internal::CachedSize _cached_size_;
+    PROTOBUF_TSAN_DECLARE_MEMBER
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_stream_2eproto;
+};// -------------------------------------------------------------------
+
+class TimePowerCompensate final :
+    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:stream.TimePowerCompensate) */ {
+ public:
+  inline TimePowerCompensate() : TimePowerCompensate(nullptr) {}
+  ~TimePowerCompensate() override;
+  template<typename = void>
+  explicit PROTOBUF_CONSTEXPR TimePowerCompensate(::google::protobuf::internal::ConstantInitialized);
+
+  TimePowerCompensate(const TimePowerCompensate& from);
+  TimePowerCompensate(TimePowerCompensate&& from) noexcept
+    : TimePowerCompensate() {
+    *this = ::std::move(from);
+  }
+
+  inline TimePowerCompensate& operator=(const TimePowerCompensate& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline TimePowerCompensate& operator=(TimePowerCompensate&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
+  }
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::google::protobuf::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::google::protobuf::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const TimePowerCompensate& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const TimePowerCompensate* internal_default_instance() {
+    return reinterpret_cast<const TimePowerCompensate*>(
+               &_TimePowerCompensate_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    20;
+
+  friend void swap(TimePowerCompensate& a, TimePowerCompensate& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(TimePowerCompensate* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::google::protobuf::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(TimePowerCompensate* other) {
+    if (other == this) return;
+    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  TimePowerCompensate* New(::google::protobuf::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<TimePowerCompensate>(arena);
+  }
+  using ::google::protobuf::Message::CopyFrom;
+  void CopyFrom(const TimePowerCompensate& from);
+  using ::google::protobuf::Message::MergeFrom;
+  void MergeFrom( const TimePowerCompensate& from) {
+    TimePowerCompensate::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  ::size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
+  ::uint8_t* _InternalSerialize(
+      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::google::protobuf::Arena* arena);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(TimePowerCompensate* other);
+
+  private:
+  friend class ::google::protobuf::internal::AnyMetadata;
+  static ::absl::string_view FullMessageName() {
+    return "stream.TimePowerCompensate";
+  }
+  protected:
+  explicit TimePowerCompensate(::google::protobuf::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::google::protobuf::Message::ClassData*GetClassData() const final;
+
+  ::google::protobuf::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kIdFieldNumber = 1,
+    kCnoFieldNumber = 2,
+    kStartMinuteFieldNumber = 3,
+    kEndMinuteFieldNumber = 4,
+    kCompensateFieldNumber = 5,
+  };
+  // int32 id = 1;
+  void clear_id() ;
+  ::int32_t id() const;
+  void set_id(::int32_t value);
+
+  private:
+  ::int32_t _internal_id() const;
+  void _internal_set_id(::int32_t value);
+
+  public:
+  // int32 cno = 2;
+  void clear_cno() ;
+  ::int32_t cno() const;
+  void set_cno(::int32_t value);
+
+  private:
+  ::int32_t _internal_cno() const;
+  void _internal_set_cno(::int32_t value);
+
+  public:
+  // uint32 startMinute = 3;
+  void clear_startminute() ;
+  ::uint32_t startminute() const;
+  void set_startminute(::uint32_t value);
+
+  private:
+  ::uint32_t _internal_startminute() const;
+  void _internal_set_startminute(::uint32_t value);
+
+  public:
+  // uint32 endMinute = 4;
+  void clear_endminute() ;
+  ::uint32_t endminute() const;
+  void set_endminute(::uint32_t value);
+
+  private:
+  ::uint32_t _internal_endminute() const;
+  void _internal_set_endminute(::uint32_t value);
+
+  public:
+  // float compensate = 5;
+  void clear_compensate() ;
+  float compensate() const;
+  void set_compensate(float value);
+
+  private:
+  float _internal_compensate() const;
+  void _internal_set_compensate(float value);
+
+  public:
+  // @@protoc_insertion_point(class_scope:stream.TimePowerCompensate)
+ private:
+  class _Internal;
+
+  friend class ::google::protobuf::internal::TcParser;
+  static const ::google::protobuf::internal::TcParseTable<3, 5, 0, 0, 2> _table_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::int32_t id_;
+    ::int32_t cno_;
+    ::uint32_t startminute_;
+    ::uint32_t endminute_;
+    float compensate_;
+    mutable ::google::protobuf::internal::CachedSize _cached_size_;
+    PROTOBUF_TSAN_DECLARE_MEMBER
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_stream_2eproto;
 };
 
 // ===================================================================
@@ -2873,6 +5962,240 @@ inline void ParamInfo::_internal_set_powder(float value) {
   _impl_.powder_ = value;
 }
 
+// int32 seqNo = 11;
+inline void ParamInfo::clear_seqno() {
+  _impl_.seqno_ = 0;
+}
+inline ::int32_t ParamInfo::seqno() const {
+  // @@protoc_insertion_point(field_get:stream.ParamInfo.seqNo)
+  return _internal_seqno();
+}
+inline void ParamInfo::set_seqno(::int32_t value) {
+  _internal_set_seqno(value);
+  // @@protoc_insertion_point(field_set:stream.ParamInfo.seqNo)
+}
+inline ::int32_t ParamInfo::_internal_seqno() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.seqno_;
+}
+inline void ParamInfo::_internal_set_seqno(::int32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.seqno_ = value;
+}
+
+// int32 controlNo = 12;
+inline void ParamInfo::clear_controlno() {
+  _impl_.controlno_ = 0;
+}
+inline ::int32_t ParamInfo::controlno() const {
+  // @@protoc_insertion_point(field_get:stream.ParamInfo.controlNo)
+  return _internal_controlno();
+}
+inline void ParamInfo::set_controlno(::int32_t value) {
+  _internal_set_controlno(value);
+  // @@protoc_insertion_point(field_set:stream.ParamInfo.controlNo)
+}
+inline ::int32_t ParamInfo::_internal_controlno() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.controlno_;
+}
+inline void ParamInfo::_internal_set_controlno(::int32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.controlno_ = value;
+}
+
+// int32 serialNo = 13;
+inline void ParamInfo::clear_serialno() {
+  _impl_.serialno_ = 0;
+}
+inline ::int32_t ParamInfo::serialno() const {
+  // @@protoc_insertion_point(field_get:stream.ParamInfo.serialNo)
+  return _internal_serialno();
+}
+inline void ParamInfo::set_serialno(::int32_t value) {
+  _internal_set_serialno(value);
+  // @@protoc_insertion_point(field_set:stream.ParamInfo.serialNo)
+}
+inline ::int32_t ParamInfo::_internal_serialno() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.serialno_;
+}
+inline void ParamInfo::_internal_set_serialno(::int32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.serialno_ = value;
+}
+
+// int32 controlType = 14;
+inline void ParamInfo::clear_controltype() {
+  _impl_.controltype_ = 0;
+}
+inline ::int32_t ParamInfo::controltype() const {
+  // @@protoc_insertion_point(field_get:stream.ParamInfo.controlType)
+  return _internal_controltype();
+}
+inline void ParamInfo::set_controltype(::int32_t value) {
+  _internal_set_controltype(value);
+  // @@protoc_insertion_point(field_set:stream.ParamInfo.controlType)
+}
+inline ::int32_t ParamInfo::_internal_controltype() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.controltype_;
+}
+inline void ParamInfo::_internal_set_controltype(::int32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.controltype_ = value;
+}
+
+// bytes cardName = 15;
+inline void ParamInfo::clear_cardname() {
+  _impl_.cardname_.ClearToEmpty();
+}
+inline const std::string& ParamInfo::cardname() const {
+  // @@protoc_insertion_point(field_get:stream.ParamInfo.cardName)
+  return _internal_cardname();
+}
+template <typename Arg_, typename... Args_>
+inline PROTOBUF_ALWAYS_INLINE void ParamInfo::set_cardname(Arg_&& arg,
+                                                     Args_... args) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.cardname_.SetBytes(static_cast<Arg_&&>(arg), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:stream.ParamInfo.cardName)
+}
+inline std::string* ParamInfo::mutable_cardname() {
+  std::string* _s = _internal_mutable_cardname();
+  // @@protoc_insertion_point(field_mutable:stream.ParamInfo.cardName)
+  return _s;
+}
+inline const std::string& ParamInfo::_internal_cardname() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.cardname_.Get();
+}
+inline void ParamInfo::_internal_set_cardname(const std::string& value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.cardname_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ParamInfo::_internal_mutable_cardname() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  return _impl_.cardname_.Mutable( GetArenaForAllocation());
+}
+inline std::string* ParamInfo::release_cardname() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  // @@protoc_insertion_point(field_release:stream.ParamInfo.cardName)
+  return _impl_.cardname_.Release();
+}
+inline void ParamInfo::set_allocated_cardname(std::string* value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  _impl_.cardname_.SetAllocated(value, GetArenaForAllocation());
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        if (_impl_.cardname_.IsDefault()) {
+          _impl_.cardname_.Set("", GetArenaForAllocation());
+        }
+  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:stream.ParamInfo.cardName)
+}
+
+// bytes cardIP = 16;
+inline void ParamInfo::clear_cardip() {
+  _impl_.cardip_.ClearToEmpty();
+}
+inline const std::string& ParamInfo::cardip() const {
+  // @@protoc_insertion_point(field_get:stream.ParamInfo.cardIP)
+  return _internal_cardip();
+}
+template <typename Arg_, typename... Args_>
+inline PROTOBUF_ALWAYS_INLINE void ParamInfo::set_cardip(Arg_&& arg,
+                                                     Args_... args) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.cardip_.SetBytes(static_cast<Arg_&&>(arg), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:stream.ParamInfo.cardIP)
+}
+inline std::string* ParamInfo::mutable_cardip() {
+  std::string* _s = _internal_mutable_cardip();
+  // @@protoc_insertion_point(field_mutable:stream.ParamInfo.cardIP)
+  return _s;
+}
+inline const std::string& ParamInfo::_internal_cardip() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.cardip_.Get();
+}
+inline void ParamInfo::_internal_set_cardip(const std::string& value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.cardip_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ParamInfo::_internal_mutable_cardip() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  return _impl_.cardip_.Mutable( GetArenaForAllocation());
+}
+inline std::string* ParamInfo::release_cardip() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  // @@protoc_insertion_point(field_release:stream.ParamInfo.cardIP)
+  return _impl_.cardip_.Release();
+}
+inline void ParamInfo::set_allocated_cardip(std::string* value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  _impl_.cardip_.SetAllocated(value, GetArenaForAllocation());
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        if (_impl_.cardip_.IsDefault()) {
+          _impl_.cardip_.Set("", GetArenaForAllocation());
+        }
+  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:stream.ParamInfo.cardIP)
+}
+
+// bool hadAssign = 17;
+inline void ParamInfo::clear_hadassign() {
+  _impl_.hadassign_ = false;
+}
+inline bool ParamInfo::hadassign() const {
+  // @@protoc_insertion_point(field_get:stream.ParamInfo.hadAssign)
+  return _internal_hadassign();
+}
+inline void ParamInfo::set_hadassign(bool value) {
+  _internal_set_hadassign(value);
+  // @@protoc_insertion_point(field_set:stream.ParamInfo.hadAssign)
+}
+inline bool ParamInfo::_internal_hadassign() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.hadassign_;
+}
+inline void ParamInfo::_internal_set_hadassign(bool value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.hadassign_ = value;
+}
+
+// bool hadMatch = 18;
+inline void ParamInfo::clear_hadmatch() {
+  _impl_.hadmatch_ = false;
+}
+inline bool ParamInfo::hadmatch() const {
+  // @@protoc_insertion_point(field_get:stream.ParamInfo.hadMatch)
+  return _internal_hadmatch();
+}
+inline void ParamInfo::set_hadmatch(bool value) {
+  _internal_set_hadmatch(value);
+  // @@protoc_insertion_point(field_set:stream.ParamInfo.hadMatch)
+}
+inline bool ParamInfo::_internal_hadmatch() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.hadmatch_;
+}
+inline void ParamInfo::_internal_set_hadmatch(bool value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.hadmatch_ = value;
+}
+
 // -------------------------------------------------------------------
 
 // RequestInfo
@@ -3966,6 +7289,3574 @@ inline void ComResponce::set_allocated_data(std::string* value) {
   // @@protoc_insertion_point(field_set_allocated:stream.ComResponce.data)
 }
 
+// -------------------------------------------------------------------
+
+// ScannerCrtlCfgResp
+
+// repeated .stream.ScannerCrtlCfgData scannerCfg = 1;
+inline int ScannerCrtlCfgResp::_internal_scannercfg_size() const {
+  return _internal_scannercfg().size();
+}
+inline int ScannerCrtlCfgResp::scannercfg_size() const {
+  return _internal_scannercfg_size();
+}
+inline void ScannerCrtlCfgResp::clear_scannercfg() {
+  _internal_mutable_scannercfg()->Clear();
+}
+inline ::stream::ScannerCrtlCfgData* ScannerCrtlCfgResp::mutable_scannercfg(int index) {
+  // @@protoc_insertion_point(field_mutable:stream.ScannerCrtlCfgResp.scannerCfg)
+  return _internal_mutable_scannercfg()->Mutable(index);
+}
+inline ::google::protobuf::RepeatedPtrField< ::stream::ScannerCrtlCfgData >*
+ScannerCrtlCfgResp::mutable_scannercfg() {
+  // @@protoc_insertion_point(field_mutable_list:stream.ScannerCrtlCfgResp.scannerCfg)
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  return _internal_mutable_scannercfg();
+}
+inline const ::stream::ScannerCrtlCfgData& ScannerCrtlCfgResp::scannercfg(int index) const {
+  // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgResp.scannerCfg)
+    return _internal_scannercfg().Get(index);
+}
+inline ::stream::ScannerCrtlCfgData* ScannerCrtlCfgResp::add_scannercfg() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ::stream::ScannerCrtlCfgData* _add = _internal_mutable_scannercfg()->Add();
+  // @@protoc_insertion_point(field_add:stream.ScannerCrtlCfgResp.scannerCfg)
+  return _add;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::stream::ScannerCrtlCfgData >&
+ScannerCrtlCfgResp::scannercfg() const {
+  // @@protoc_insertion_point(field_list:stream.ScannerCrtlCfgResp.scannerCfg)
+  return _internal_scannercfg();
+}
+inline const ::google::protobuf::RepeatedPtrField<::stream::ScannerCrtlCfgData>&
+ScannerCrtlCfgResp::_internal_scannercfg() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.scannercfg_;
+}
+inline ::google::protobuf::RepeatedPtrField<::stream::ScannerCrtlCfgData>*
+ScannerCrtlCfgResp::_internal_mutable_scannercfg() {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return &_impl_.scannercfg_;
+}
+
+// -------------------------------------------------------------------
+
+// ScannerCrtlCfgData
+
+// int32 seqNo = 1;
+inline void ScannerCrtlCfgData::clear_seqno() {
+  _impl_.seqno_ = 0;
+}
+inline ::int32_t ScannerCrtlCfgData::seqno() const {
+  // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.seqNo)
+  return _internal_seqno();
+}
+inline void ScannerCrtlCfgData::set_seqno(::int32_t value) {
+  _internal_set_seqno(value);
+  // @@protoc_insertion_point(field_set:stream.ScannerCrtlCfgData.seqNo)
+}
+inline ::int32_t ScannerCrtlCfgData::_internal_seqno() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.seqno_;
+}
+inline void ScannerCrtlCfgData::_internal_set_seqno(::int32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.seqno_ = value;
+}
+
+// repeated .stream.FixPointData fixPointData = 2;
+inline int ScannerCrtlCfgData::_internal_fixpointdata_size() const {
+  return _internal_fixpointdata().size();
+}
+inline int ScannerCrtlCfgData::fixpointdata_size() const {
+  return _internal_fixpointdata_size();
+}
+inline void ScannerCrtlCfgData::clear_fixpointdata() {
+  _internal_mutable_fixpointdata()->Clear();
+}
+inline ::stream::FixPointData* ScannerCrtlCfgData::mutable_fixpointdata(int index) {
+  // @@protoc_insertion_point(field_mutable:stream.ScannerCrtlCfgData.fixPointData)
+  return _internal_mutable_fixpointdata()->Mutable(index);
+}
+inline ::google::protobuf::RepeatedPtrField< ::stream::FixPointData >*
+ScannerCrtlCfgData::mutable_fixpointdata() {
+  // @@protoc_insertion_point(field_mutable_list:stream.ScannerCrtlCfgData.fixPointData)
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  return _internal_mutable_fixpointdata();
+}
+inline const ::stream::FixPointData& ScannerCrtlCfgData::fixpointdata(int index) const {
+  // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.fixPointData)
+    return _internal_fixpointdata().Get(index);
+}
+inline ::stream::FixPointData* ScannerCrtlCfgData::add_fixpointdata() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ::stream::FixPointData* _add = _internal_mutable_fixpointdata()->Add();
+  // @@protoc_insertion_point(field_add:stream.ScannerCrtlCfgData.fixPointData)
+  return _add;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::stream::FixPointData >&
+ScannerCrtlCfgData::fixpointdata() const {
+  // @@protoc_insertion_point(field_list:stream.ScannerCrtlCfgData.fixPointData)
+  return _internal_fixpointdata();
+}
+inline const ::google::protobuf::RepeatedPtrField<::stream::FixPointData>&
+ScannerCrtlCfgData::_internal_fixpointdata() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.fixpointdata_;
+}
+inline ::google::protobuf::RepeatedPtrField<::stream::FixPointData>*
+ScannerCrtlCfgData::_internal_mutable_fixpointdata() {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return &_impl_.fixpointdata_;
+}
+
+// .stream.ScanParamCfg scanParamCfg = 3;
+inline bool ScannerCrtlCfgData::has_scanparamcfg() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.scanparamcfg_ != nullptr);
+  return value;
+}
+inline void ScannerCrtlCfgData::clear_scanparamcfg() {
+  if (_impl_.scanparamcfg_ != nullptr) _impl_.scanparamcfg_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const ::stream::ScanParamCfg& ScannerCrtlCfgData::_internal_scanparamcfg() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  const ::stream::ScanParamCfg* p = _impl_.scanparamcfg_;
+  return p != nullptr ? *p : reinterpret_cast<const ::stream::ScanParamCfg&>(::stream::_ScanParamCfg_default_instance_);
+}
+inline const ::stream::ScanParamCfg& ScannerCrtlCfgData::scanparamcfg() const {
+  // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.scanParamCfg)
+  return _internal_scanparamcfg();
+}
+inline void ScannerCrtlCfgData::unsafe_arena_set_allocated_scanparamcfg(::stream::ScanParamCfg* value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.scanparamcfg_);
+  }
+  _impl_.scanparamcfg_ = reinterpret_cast<::stream::ScanParamCfg*>(value);
+  if (value != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:stream.ScannerCrtlCfgData.scanParamCfg)
+}
+inline ::stream::ScanParamCfg* ScannerCrtlCfgData::release_scanparamcfg() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::stream::ScanParamCfg* released = _impl_.scanparamcfg_;
+  _impl_.scanparamcfg_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
+  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
+  if (GetArenaForAllocation() == nullptr) {
+    delete old;
+  }
+#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return released;
+}
+inline ::stream::ScanParamCfg* ScannerCrtlCfgData::unsafe_arena_release_scanparamcfg() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  // @@protoc_insertion_point(field_release:stream.ScannerCrtlCfgData.scanParamCfg)
+
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::stream::ScanParamCfg* temp = _impl_.scanparamcfg_;
+  _impl_.scanparamcfg_ = nullptr;
+  return temp;
+}
+inline ::stream::ScanParamCfg* ScannerCrtlCfgData::_internal_mutable_scanparamcfg() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  _impl_._has_bits_[0] |= 0x00000001u;
+  if (_impl_.scanparamcfg_ == nullptr) {
+    auto* p = CreateMaybeMessage<::stream::ScanParamCfg>(GetArenaForAllocation());
+    _impl_.scanparamcfg_ = reinterpret_cast<::stream::ScanParamCfg*>(p);
+  }
+  return _impl_.scanparamcfg_;
+}
+inline ::stream::ScanParamCfg* ScannerCrtlCfgData::mutable_scanparamcfg() {
+  ::stream::ScanParamCfg* _msg = _internal_mutable_scanparamcfg();
+  // @@protoc_insertion_point(field_mutable:stream.ScannerCrtlCfgData.scanParamCfg)
+  return _msg;
+}
+inline void ScannerCrtlCfgData::set_allocated_scanparamcfg(::stream::ScanParamCfg* value) {
+  ::google::protobuf::Arena* message_arena = GetArenaForAllocation();
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  if (message_arena == nullptr) {
+    delete reinterpret_cast<::stream::ScanParamCfg*>(_impl_.scanparamcfg_);
+  }
+
+  if (value != nullptr) {
+    ::google::protobuf::Arena* submessage_arena =
+        ::google::protobuf::Arena::InternalGetOwningArena(reinterpret_cast<::stream::ScanParamCfg*>(value));
+    if (message_arena != submessage_arena) {
+      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+
+  _impl_.scanparamcfg_ = reinterpret_cast<::stream::ScanParamCfg*>(value);
+  // @@protoc_insertion_point(field_set_allocated:stream.ScannerCrtlCfgData.scanParamCfg)
+}
+
+// .stream.ScanParamCfg hatchingParams = 4;
+inline bool ScannerCrtlCfgData::has_hatchingparams() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.hatchingparams_ != nullptr);
+  return value;
+}
+inline void ScannerCrtlCfgData::clear_hatchingparams() {
+  if (_impl_.hatchingparams_ != nullptr) _impl_.hatchingparams_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::stream::ScanParamCfg& ScannerCrtlCfgData::_internal_hatchingparams() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  const ::stream::ScanParamCfg* p = _impl_.hatchingparams_;
+  return p != nullptr ? *p : reinterpret_cast<const ::stream::ScanParamCfg&>(::stream::_ScanParamCfg_default_instance_);
+}
+inline const ::stream::ScanParamCfg& ScannerCrtlCfgData::hatchingparams() const {
+  // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.hatchingParams)
+  return _internal_hatchingparams();
+}
+inline void ScannerCrtlCfgData::unsafe_arena_set_allocated_hatchingparams(::stream::ScanParamCfg* value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.hatchingparams_);
+  }
+  _impl_.hatchingparams_ = reinterpret_cast<::stream::ScanParamCfg*>(value);
+  if (value != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:stream.ScannerCrtlCfgData.hatchingParams)
+}
+inline ::stream::ScanParamCfg* ScannerCrtlCfgData::release_hatchingparams() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::stream::ScanParamCfg* released = _impl_.hatchingparams_;
+  _impl_.hatchingparams_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
+  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
+  if (GetArenaForAllocation() == nullptr) {
+    delete old;
+  }
+#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return released;
+}
+inline ::stream::ScanParamCfg* ScannerCrtlCfgData::unsafe_arena_release_hatchingparams() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  // @@protoc_insertion_point(field_release:stream.ScannerCrtlCfgData.hatchingParams)
+
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::stream::ScanParamCfg* temp = _impl_.hatchingparams_;
+  _impl_.hatchingparams_ = nullptr;
+  return temp;
+}
+inline ::stream::ScanParamCfg* ScannerCrtlCfgData::_internal_mutable_hatchingparams() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.hatchingparams_ == nullptr) {
+    auto* p = CreateMaybeMessage<::stream::ScanParamCfg>(GetArenaForAllocation());
+    _impl_.hatchingparams_ = reinterpret_cast<::stream::ScanParamCfg*>(p);
+  }
+  return _impl_.hatchingparams_;
+}
+inline ::stream::ScanParamCfg* ScannerCrtlCfgData::mutable_hatchingparams() {
+  ::stream::ScanParamCfg* _msg = _internal_mutable_hatchingparams();
+  // @@protoc_insertion_point(field_mutable:stream.ScannerCrtlCfgData.hatchingParams)
+  return _msg;
+}
+inline void ScannerCrtlCfgData::set_allocated_hatchingparams(::stream::ScanParamCfg* value) {
+  ::google::protobuf::Arena* message_arena = GetArenaForAllocation();
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  if (message_arena == nullptr) {
+    delete reinterpret_cast<::stream::ScanParamCfg*>(_impl_.hatchingparams_);
+  }
+
+  if (value != nullptr) {
+    ::google::protobuf::Arena* submessage_arena =
+        ::google::protobuf::Arena::InternalGetOwningArena(reinterpret_cast<::stream::ScanParamCfg*>(value));
+    if (message_arena != submessage_arena) {
+      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+
+  _impl_.hatchingparams_ = reinterpret_cast<::stream::ScanParamCfg*>(value);
+  // @@protoc_insertion_point(field_set_allocated:stream.ScannerCrtlCfgData.hatchingParams)
+}
+
+// .stream.ScanParamCfg borderParams = 5;
+inline bool ScannerCrtlCfgData::has_borderparams() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.borderparams_ != nullptr);
+  return value;
+}
+inline void ScannerCrtlCfgData::clear_borderparams() {
+  if (_impl_.borderparams_ != nullptr) _impl_.borderparams_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const ::stream::ScanParamCfg& ScannerCrtlCfgData::_internal_borderparams() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  const ::stream::ScanParamCfg* p = _impl_.borderparams_;
+  return p != nullptr ? *p : reinterpret_cast<const ::stream::ScanParamCfg&>(::stream::_ScanParamCfg_default_instance_);
+}
+inline const ::stream::ScanParamCfg& ScannerCrtlCfgData::borderparams() const {
+  // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.borderParams)
+  return _internal_borderparams();
+}
+inline void ScannerCrtlCfgData::unsafe_arena_set_allocated_borderparams(::stream::ScanParamCfg* value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.borderparams_);
+  }
+  _impl_.borderparams_ = reinterpret_cast<::stream::ScanParamCfg*>(value);
+  if (value != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:stream.ScannerCrtlCfgData.borderParams)
+}
+inline ::stream::ScanParamCfg* ScannerCrtlCfgData::release_borderparams() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::stream::ScanParamCfg* released = _impl_.borderparams_;
+  _impl_.borderparams_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
+  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
+  if (GetArenaForAllocation() == nullptr) {
+    delete old;
+  }
+#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return released;
+}
+inline ::stream::ScanParamCfg* ScannerCrtlCfgData::unsafe_arena_release_borderparams() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  // @@protoc_insertion_point(field_release:stream.ScannerCrtlCfgData.borderParams)
+
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::stream::ScanParamCfg* temp = _impl_.borderparams_;
+  _impl_.borderparams_ = nullptr;
+  return temp;
+}
+inline ::stream::ScanParamCfg* ScannerCrtlCfgData::_internal_mutable_borderparams() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  _impl_._has_bits_[0] |= 0x00000004u;
+  if (_impl_.borderparams_ == nullptr) {
+    auto* p = CreateMaybeMessage<::stream::ScanParamCfg>(GetArenaForAllocation());
+    _impl_.borderparams_ = reinterpret_cast<::stream::ScanParamCfg*>(p);
+  }
+  return _impl_.borderparams_;
+}
+inline ::stream::ScanParamCfg* ScannerCrtlCfgData::mutable_borderparams() {
+  ::stream::ScanParamCfg* _msg = _internal_mutable_borderparams();
+  // @@protoc_insertion_point(field_mutable:stream.ScannerCrtlCfgData.borderParams)
+  return _msg;
+}
+inline void ScannerCrtlCfgData::set_allocated_borderparams(::stream::ScanParamCfg* value) {
+  ::google::protobuf::Arena* message_arena = GetArenaForAllocation();
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  if (message_arena == nullptr) {
+    delete reinterpret_cast<::stream::ScanParamCfg*>(_impl_.borderparams_);
+  }
+
+  if (value != nullptr) {
+    ::google::protobuf::Arena* submessage_arena =
+        ::google::protobuf::Arena::InternalGetOwningArena(reinterpret_cast<::stream::ScanParamCfg*>(value));
+    if (message_arena != submessage_arena) {
+      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+
+  _impl_.borderparams_ = reinterpret_cast<::stream::ScanParamCfg*>(value);
+  // @@protoc_insertion_point(field_set_allocated:stream.ScannerCrtlCfgData.borderParams)
+}
+
+// .stream.ScanParamCfg supportParams = 6;
+inline bool ScannerCrtlCfgData::has_supportparams() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.supportparams_ != nullptr);
+  return value;
+}
+inline void ScannerCrtlCfgData::clear_supportparams() {
+  if (_impl_.supportparams_ != nullptr) _impl_.supportparams_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const ::stream::ScanParamCfg& ScannerCrtlCfgData::_internal_supportparams() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  const ::stream::ScanParamCfg* p = _impl_.supportparams_;
+  return p != nullptr ? *p : reinterpret_cast<const ::stream::ScanParamCfg&>(::stream::_ScanParamCfg_default_instance_);
+}
+inline const ::stream::ScanParamCfg& ScannerCrtlCfgData::supportparams() const {
+  // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.supportParams)
+  return _internal_supportparams();
+}
+inline void ScannerCrtlCfgData::unsafe_arena_set_allocated_supportparams(::stream::ScanParamCfg* value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.supportparams_);
+  }
+  _impl_.supportparams_ = reinterpret_cast<::stream::ScanParamCfg*>(value);
+  if (value != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:stream.ScannerCrtlCfgData.supportParams)
+}
+inline ::stream::ScanParamCfg* ScannerCrtlCfgData::release_supportparams() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  ::stream::ScanParamCfg* released = _impl_.supportparams_;
+  _impl_.supportparams_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
+  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
+  if (GetArenaForAllocation() == nullptr) {
+    delete old;
+  }
+#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return released;
+}
+inline ::stream::ScanParamCfg* ScannerCrtlCfgData::unsafe_arena_release_supportparams() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  // @@protoc_insertion_point(field_release:stream.ScannerCrtlCfgData.supportParams)
+
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  ::stream::ScanParamCfg* temp = _impl_.supportparams_;
+  _impl_.supportparams_ = nullptr;
+  return temp;
+}
+inline ::stream::ScanParamCfg* ScannerCrtlCfgData::_internal_mutable_supportparams() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  _impl_._has_bits_[0] |= 0x00000008u;
+  if (_impl_.supportparams_ == nullptr) {
+    auto* p = CreateMaybeMessage<::stream::ScanParamCfg>(GetArenaForAllocation());
+    _impl_.supportparams_ = reinterpret_cast<::stream::ScanParamCfg*>(p);
+  }
+  return _impl_.supportparams_;
+}
+inline ::stream::ScanParamCfg* ScannerCrtlCfgData::mutable_supportparams() {
+  ::stream::ScanParamCfg* _msg = _internal_mutable_supportparams();
+  // @@protoc_insertion_point(field_mutable:stream.ScannerCrtlCfgData.supportParams)
+  return _msg;
+}
+inline void ScannerCrtlCfgData::set_allocated_supportparams(::stream::ScanParamCfg* value) {
+  ::google::protobuf::Arena* message_arena = GetArenaForAllocation();
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  if (message_arena == nullptr) {
+    delete reinterpret_cast<::stream::ScanParamCfg*>(_impl_.supportparams_);
+  }
+
+  if (value != nullptr) {
+    ::google::protobuf::Arena* submessage_arena =
+        ::google::protobuf::Arena::InternalGetOwningArena(reinterpret_cast<::stream::ScanParamCfg*>(value));
+    if (message_arena != submessage_arena) {
+      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+
+  _impl_.supportparams_ = reinterpret_cast<::stream::ScanParamCfg*>(value);
+  // @@protoc_insertion_point(field_set_allocated:stream.ScannerCrtlCfgData.supportParams)
+}
+
+// .stream.CorrectParamCfg correctParamCfg = 7;
+inline bool ScannerCrtlCfgData::has_correctparamcfg() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.correctparamcfg_ != nullptr);
+  return value;
+}
+inline void ScannerCrtlCfgData::clear_correctparamcfg() {
+  if (_impl_.correctparamcfg_ != nullptr) _impl_.correctparamcfg_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline const ::stream::CorrectParamCfg& ScannerCrtlCfgData::_internal_correctparamcfg() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  const ::stream::CorrectParamCfg* p = _impl_.correctparamcfg_;
+  return p != nullptr ? *p : reinterpret_cast<const ::stream::CorrectParamCfg&>(::stream::_CorrectParamCfg_default_instance_);
+}
+inline const ::stream::CorrectParamCfg& ScannerCrtlCfgData::correctparamcfg() const {
+  // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.correctParamCfg)
+  return _internal_correctparamcfg();
+}
+inline void ScannerCrtlCfgData::unsafe_arena_set_allocated_correctparamcfg(::stream::CorrectParamCfg* value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.correctparamcfg_);
+  }
+  _impl_.correctparamcfg_ = reinterpret_cast<::stream::CorrectParamCfg*>(value);
+  if (value != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:stream.ScannerCrtlCfgData.correctParamCfg)
+}
+inline ::stream::CorrectParamCfg* ScannerCrtlCfgData::release_correctparamcfg() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  ::stream::CorrectParamCfg* released = _impl_.correctparamcfg_;
+  _impl_.correctparamcfg_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
+  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
+  if (GetArenaForAllocation() == nullptr) {
+    delete old;
+  }
+#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return released;
+}
+inline ::stream::CorrectParamCfg* ScannerCrtlCfgData::unsafe_arena_release_correctparamcfg() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  // @@protoc_insertion_point(field_release:stream.ScannerCrtlCfgData.correctParamCfg)
+
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  ::stream::CorrectParamCfg* temp = _impl_.correctparamcfg_;
+  _impl_.correctparamcfg_ = nullptr;
+  return temp;
+}
+inline ::stream::CorrectParamCfg* ScannerCrtlCfgData::_internal_mutable_correctparamcfg() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  _impl_._has_bits_[0] |= 0x00000010u;
+  if (_impl_.correctparamcfg_ == nullptr) {
+    auto* p = CreateMaybeMessage<::stream::CorrectParamCfg>(GetArenaForAllocation());
+    _impl_.correctparamcfg_ = reinterpret_cast<::stream::CorrectParamCfg*>(p);
+  }
+  return _impl_.correctparamcfg_;
+}
+inline ::stream::CorrectParamCfg* ScannerCrtlCfgData::mutable_correctparamcfg() {
+  ::stream::CorrectParamCfg* _msg = _internal_mutable_correctparamcfg();
+  // @@protoc_insertion_point(field_mutable:stream.ScannerCrtlCfgData.correctParamCfg)
+  return _msg;
+}
+inline void ScannerCrtlCfgData::set_allocated_correctparamcfg(::stream::CorrectParamCfg* value) {
+  ::google::protobuf::Arena* message_arena = GetArenaForAllocation();
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  if (message_arena == nullptr) {
+    delete reinterpret_cast<::stream::CorrectParamCfg*>(_impl_.correctparamcfg_);
+  }
+
+  if (value != nullptr) {
+    ::google::protobuf::Arena* submessage_arena =
+        ::google::protobuf::Arena::InternalGetOwningArena(reinterpret_cast<::stream::CorrectParamCfg*>(value));
+    if (message_arena != submessage_arena) {
+      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+
+  _impl_.correctparamcfg_ = reinterpret_cast<::stream::CorrectParamCfg*>(value);
+  // @@protoc_insertion_point(field_set_allocated:stream.ScannerCrtlCfgData.correctParamCfg)
+}
+
+// .stream.ScanTestCfg scanTestCfg = 8;
+inline bool ScannerCrtlCfgData::has_scantestcfg() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.scantestcfg_ != nullptr);
+  return value;
+}
+inline void ScannerCrtlCfgData::clear_scantestcfg() {
+  if (_impl_.scantestcfg_ != nullptr) _impl_.scantestcfg_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline const ::stream::ScanTestCfg& ScannerCrtlCfgData::_internal_scantestcfg() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  const ::stream::ScanTestCfg* p = _impl_.scantestcfg_;
+  return p != nullptr ? *p : reinterpret_cast<const ::stream::ScanTestCfg&>(::stream::_ScanTestCfg_default_instance_);
+}
+inline const ::stream::ScanTestCfg& ScannerCrtlCfgData::scantestcfg() const {
+  // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.scanTestCfg)
+  return _internal_scantestcfg();
+}
+inline void ScannerCrtlCfgData::unsafe_arena_set_allocated_scantestcfg(::stream::ScanTestCfg* value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.scantestcfg_);
+  }
+  _impl_.scantestcfg_ = reinterpret_cast<::stream::ScanTestCfg*>(value);
+  if (value != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000020u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000020u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:stream.ScannerCrtlCfgData.scanTestCfg)
+}
+inline ::stream::ScanTestCfg* ScannerCrtlCfgData::release_scantestcfg() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+
+  _impl_._has_bits_[0] &= ~0x00000020u;
+  ::stream::ScanTestCfg* released = _impl_.scantestcfg_;
+  _impl_.scantestcfg_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
+  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
+  if (GetArenaForAllocation() == nullptr) {
+    delete old;
+  }
+#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return released;
+}
+inline ::stream::ScanTestCfg* ScannerCrtlCfgData::unsafe_arena_release_scantestcfg() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  // @@protoc_insertion_point(field_release:stream.ScannerCrtlCfgData.scanTestCfg)
+
+  _impl_._has_bits_[0] &= ~0x00000020u;
+  ::stream::ScanTestCfg* temp = _impl_.scantestcfg_;
+  _impl_.scantestcfg_ = nullptr;
+  return temp;
+}
+inline ::stream::ScanTestCfg* ScannerCrtlCfgData::_internal_mutable_scantestcfg() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  _impl_._has_bits_[0] |= 0x00000020u;
+  if (_impl_.scantestcfg_ == nullptr) {
+    auto* p = CreateMaybeMessage<::stream::ScanTestCfg>(GetArenaForAllocation());
+    _impl_.scantestcfg_ = reinterpret_cast<::stream::ScanTestCfg*>(p);
+  }
+  return _impl_.scantestcfg_;
+}
+inline ::stream::ScanTestCfg* ScannerCrtlCfgData::mutable_scantestcfg() {
+  ::stream::ScanTestCfg* _msg = _internal_mutable_scantestcfg();
+  // @@protoc_insertion_point(field_mutable:stream.ScannerCrtlCfgData.scanTestCfg)
+  return _msg;
+}
+inline void ScannerCrtlCfgData::set_allocated_scantestcfg(::stream::ScanTestCfg* value) {
+  ::google::protobuf::Arena* message_arena = GetArenaForAllocation();
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  if (message_arena == nullptr) {
+    delete reinterpret_cast<::stream::ScanTestCfg*>(_impl_.scantestcfg_);
+  }
+
+  if (value != nullptr) {
+    ::google::protobuf::Arena* submessage_arena =
+        ::google::protobuf::Arena::InternalGetOwningArena(reinterpret_cast<::stream::ScanTestCfg*>(value));
+    if (message_arena != submessage_arena) {
+      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000020u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000020u;
+  }
+
+  _impl_.scantestcfg_ = reinterpret_cast<::stream::ScanTestCfg*>(value);
+  // @@protoc_insertion_point(field_set_allocated:stream.ScannerCrtlCfgData.scanTestCfg)
+}
+
+// .stream.SkyWritingCfg skyWritingCfg = 9;
+inline bool ScannerCrtlCfgData::has_skywritingcfg() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.skywritingcfg_ != nullptr);
+  return value;
+}
+inline void ScannerCrtlCfgData::clear_skywritingcfg() {
+  if (_impl_.skywritingcfg_ != nullptr) _impl_.skywritingcfg_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000040u;
+}
+inline const ::stream::SkyWritingCfg& ScannerCrtlCfgData::_internal_skywritingcfg() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  const ::stream::SkyWritingCfg* p = _impl_.skywritingcfg_;
+  return p != nullptr ? *p : reinterpret_cast<const ::stream::SkyWritingCfg&>(::stream::_SkyWritingCfg_default_instance_);
+}
+inline const ::stream::SkyWritingCfg& ScannerCrtlCfgData::skywritingcfg() const {
+  // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.skyWritingCfg)
+  return _internal_skywritingcfg();
+}
+inline void ScannerCrtlCfgData::unsafe_arena_set_allocated_skywritingcfg(::stream::SkyWritingCfg* value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.skywritingcfg_);
+  }
+  _impl_.skywritingcfg_ = reinterpret_cast<::stream::SkyWritingCfg*>(value);
+  if (value != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000040u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000040u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:stream.ScannerCrtlCfgData.skyWritingCfg)
+}
+inline ::stream::SkyWritingCfg* ScannerCrtlCfgData::release_skywritingcfg() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+
+  _impl_._has_bits_[0] &= ~0x00000040u;
+  ::stream::SkyWritingCfg* released = _impl_.skywritingcfg_;
+  _impl_.skywritingcfg_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
+  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
+  if (GetArenaForAllocation() == nullptr) {
+    delete old;
+  }
+#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return released;
+}
+inline ::stream::SkyWritingCfg* ScannerCrtlCfgData::unsafe_arena_release_skywritingcfg() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  // @@protoc_insertion_point(field_release:stream.ScannerCrtlCfgData.skyWritingCfg)
+
+  _impl_._has_bits_[0] &= ~0x00000040u;
+  ::stream::SkyWritingCfg* temp = _impl_.skywritingcfg_;
+  _impl_.skywritingcfg_ = nullptr;
+  return temp;
+}
+inline ::stream::SkyWritingCfg* ScannerCrtlCfgData::_internal_mutable_skywritingcfg() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  _impl_._has_bits_[0] |= 0x00000040u;
+  if (_impl_.skywritingcfg_ == nullptr) {
+    auto* p = CreateMaybeMessage<::stream::SkyWritingCfg>(GetArenaForAllocation());
+    _impl_.skywritingcfg_ = reinterpret_cast<::stream::SkyWritingCfg*>(p);
+  }
+  return _impl_.skywritingcfg_;
+}
+inline ::stream::SkyWritingCfg* ScannerCrtlCfgData::mutable_skywritingcfg() {
+  ::stream::SkyWritingCfg* _msg = _internal_mutable_skywritingcfg();
+  // @@protoc_insertion_point(field_mutable:stream.ScannerCrtlCfgData.skyWritingCfg)
+  return _msg;
+}
+inline void ScannerCrtlCfgData::set_allocated_skywritingcfg(::stream::SkyWritingCfg* value) {
+  ::google::protobuf::Arena* message_arena = GetArenaForAllocation();
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  if (message_arena == nullptr) {
+    delete reinterpret_cast<::stream::SkyWritingCfg*>(_impl_.skywritingcfg_);
+  }
+
+  if (value != nullptr) {
+    ::google::protobuf::Arena* submessage_arena =
+        ::google::protobuf::Arena::InternalGetOwningArena(reinterpret_cast<::stream::SkyWritingCfg*>(value));
+    if (message_arena != submessage_arena) {
+      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000040u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000040u;
+  }
+
+  _impl_.skywritingcfg_ = reinterpret_cast<::stream::SkyWritingCfg*>(value);
+  // @@protoc_insertion_point(field_set_allocated:stream.ScannerCrtlCfgData.skyWritingCfg)
+}
+
+// repeated .stream.PowerCompensate powerCompensate = 10;
+inline int ScannerCrtlCfgData::_internal_powercompensate_size() const {
+  return _internal_powercompensate().size();
+}
+inline int ScannerCrtlCfgData::powercompensate_size() const {
+  return _internal_powercompensate_size();
+}
+inline void ScannerCrtlCfgData::clear_powercompensate() {
+  _internal_mutable_powercompensate()->Clear();
+}
+inline ::stream::PowerCompensate* ScannerCrtlCfgData::mutable_powercompensate(int index) {
+  // @@protoc_insertion_point(field_mutable:stream.ScannerCrtlCfgData.powerCompensate)
+  return _internal_mutable_powercompensate()->Mutable(index);
+}
+inline ::google::protobuf::RepeatedPtrField< ::stream::PowerCompensate >*
+ScannerCrtlCfgData::mutable_powercompensate() {
+  // @@protoc_insertion_point(field_mutable_list:stream.ScannerCrtlCfgData.powerCompensate)
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  return _internal_mutable_powercompensate();
+}
+inline const ::stream::PowerCompensate& ScannerCrtlCfgData::powercompensate(int index) const {
+  // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.powerCompensate)
+    return _internal_powercompensate().Get(index);
+}
+inline ::stream::PowerCompensate* ScannerCrtlCfgData::add_powercompensate() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ::stream::PowerCompensate* _add = _internal_mutable_powercompensate()->Add();
+  // @@protoc_insertion_point(field_add:stream.ScannerCrtlCfgData.powerCompensate)
+  return _add;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::stream::PowerCompensate >&
+ScannerCrtlCfgData::powercompensate() const {
+  // @@protoc_insertion_point(field_list:stream.ScannerCrtlCfgData.powerCompensate)
+  return _internal_powercompensate();
+}
+inline const ::google::protobuf::RepeatedPtrField<::stream::PowerCompensate>&
+ScannerCrtlCfgData::_internal_powercompensate() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.powercompensate_;
+}
+inline ::google::protobuf::RepeatedPtrField<::stream::PowerCompensate>*
+ScannerCrtlCfgData::_internal_mutable_powercompensate() {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return &_impl_.powercompensate_;
+}
+
+// repeated .stream.TimePowerCompensate tPowerCompensate = 11;
+inline int ScannerCrtlCfgData::_internal_tpowercompensate_size() const {
+  return _internal_tpowercompensate().size();
+}
+inline int ScannerCrtlCfgData::tpowercompensate_size() const {
+  return _internal_tpowercompensate_size();
+}
+inline void ScannerCrtlCfgData::clear_tpowercompensate() {
+  _internal_mutable_tpowercompensate()->Clear();
+}
+inline ::stream::TimePowerCompensate* ScannerCrtlCfgData::mutable_tpowercompensate(int index) {
+  // @@protoc_insertion_point(field_mutable:stream.ScannerCrtlCfgData.tPowerCompensate)
+  return _internal_mutable_tpowercompensate()->Mutable(index);
+}
+inline ::google::protobuf::RepeatedPtrField< ::stream::TimePowerCompensate >*
+ScannerCrtlCfgData::mutable_tpowercompensate() {
+  // @@protoc_insertion_point(field_mutable_list:stream.ScannerCrtlCfgData.tPowerCompensate)
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  return _internal_mutable_tpowercompensate();
+}
+inline const ::stream::TimePowerCompensate& ScannerCrtlCfgData::tpowercompensate(int index) const {
+  // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.tPowerCompensate)
+    return _internal_tpowercompensate().Get(index);
+}
+inline ::stream::TimePowerCompensate* ScannerCrtlCfgData::add_tpowercompensate() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ::stream::TimePowerCompensate* _add = _internal_mutable_tpowercompensate()->Add();
+  // @@protoc_insertion_point(field_add:stream.ScannerCrtlCfgData.tPowerCompensate)
+  return _add;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::stream::TimePowerCompensate >&
+ScannerCrtlCfgData::tpowercompensate() const {
+  // @@protoc_insertion_point(field_list:stream.ScannerCrtlCfgData.tPowerCompensate)
+  return _internal_tpowercompensate();
+}
+inline const ::google::protobuf::RepeatedPtrField<::stream::TimePowerCompensate>&
+ScannerCrtlCfgData::_internal_tpowercompensate() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.tpowercompensate_;
+}
+inline ::google::protobuf::RepeatedPtrField<::stream::TimePowerCompensate>*
+ScannerCrtlCfgData::_internal_mutable_tpowercompensate() {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return &_impl_.tpowercompensate_;
+}
+
+// int32 controlNo = 12;
+inline void ScannerCrtlCfgData::clear_controlno() {
+  _impl_.controlno_ = 0;
+}
+inline ::int32_t ScannerCrtlCfgData::controlno() const {
+  // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.controlNo)
+  return _internal_controlno();
+}
+inline void ScannerCrtlCfgData::set_controlno(::int32_t value) {
+  _internal_set_controlno(value);
+  // @@protoc_insertion_point(field_set:stream.ScannerCrtlCfgData.controlNo)
+}
+inline ::int32_t ScannerCrtlCfgData::_internal_controlno() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.controlno_;
+}
+inline void ScannerCrtlCfgData::_internal_set_controlno(::int32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.controlno_ = value;
+}
+
+// int32 serialNo = 13;
+inline void ScannerCrtlCfgData::clear_serialno() {
+  _impl_.serialno_ = 0;
+}
+inline ::int32_t ScannerCrtlCfgData::serialno() const {
+  // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.serialNo)
+  return _internal_serialno();
+}
+inline void ScannerCrtlCfgData::set_serialno(::int32_t value) {
+  _internal_set_serialno(value);
+  // @@protoc_insertion_point(field_set:stream.ScannerCrtlCfgData.serialNo)
+}
+inline ::int32_t ScannerCrtlCfgData::_internal_serialno() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.serialno_;
+}
+inline void ScannerCrtlCfgData::_internal_set_serialno(::int32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.serialno_ = value;
+}
+
+// int32 controlType = 14;
+inline void ScannerCrtlCfgData::clear_controltype() {
+  _impl_.controltype_ = 0;
+}
+inline ::int32_t ScannerCrtlCfgData::controltype() const {
+  // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.controlType)
+  return _internal_controltype();
+}
+inline void ScannerCrtlCfgData::set_controltype(::int32_t value) {
+  _internal_set_controltype(value);
+  // @@protoc_insertion_point(field_set:stream.ScannerCrtlCfgData.controlType)
+}
+inline ::int32_t ScannerCrtlCfgData::_internal_controltype() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.controltype_;
+}
+inline void ScannerCrtlCfgData::_internal_set_controltype(::int32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.controltype_ = value;
+}
+
+// bytes cardName = 15;
+inline void ScannerCrtlCfgData::clear_cardname() {
+  _impl_.cardname_.ClearToEmpty();
+}
+inline const std::string& ScannerCrtlCfgData::cardname() const {
+  // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.cardName)
+  return _internal_cardname();
+}
+template <typename Arg_, typename... Args_>
+inline PROTOBUF_ALWAYS_INLINE void ScannerCrtlCfgData::set_cardname(Arg_&& arg,
+                                                     Args_... args) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.cardname_.SetBytes(static_cast<Arg_&&>(arg), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:stream.ScannerCrtlCfgData.cardName)
+}
+inline std::string* ScannerCrtlCfgData::mutable_cardname() {
+  std::string* _s = _internal_mutable_cardname();
+  // @@protoc_insertion_point(field_mutable:stream.ScannerCrtlCfgData.cardName)
+  return _s;
+}
+inline const std::string& ScannerCrtlCfgData::_internal_cardname() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.cardname_.Get();
+}
+inline void ScannerCrtlCfgData::_internal_set_cardname(const std::string& value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.cardname_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ScannerCrtlCfgData::_internal_mutable_cardname() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  return _impl_.cardname_.Mutable( GetArenaForAllocation());
+}
+inline std::string* ScannerCrtlCfgData::release_cardname() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  // @@protoc_insertion_point(field_release:stream.ScannerCrtlCfgData.cardName)
+  return _impl_.cardname_.Release();
+}
+inline void ScannerCrtlCfgData::set_allocated_cardname(std::string* value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  _impl_.cardname_.SetAllocated(value, GetArenaForAllocation());
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        if (_impl_.cardname_.IsDefault()) {
+          _impl_.cardname_.Set("", GetArenaForAllocation());
+        }
+  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:stream.ScannerCrtlCfgData.cardName)
+}
+
+// bytes cardIP = 16;
+inline void ScannerCrtlCfgData::clear_cardip() {
+  _impl_.cardip_.ClearToEmpty();
+}
+inline const std::string& ScannerCrtlCfgData::cardip() const {
+  // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.cardIP)
+  return _internal_cardip();
+}
+template <typename Arg_, typename... Args_>
+inline PROTOBUF_ALWAYS_INLINE void ScannerCrtlCfgData::set_cardip(Arg_&& arg,
+                                                     Args_... args) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.cardip_.SetBytes(static_cast<Arg_&&>(arg), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:stream.ScannerCrtlCfgData.cardIP)
+}
+inline std::string* ScannerCrtlCfgData::mutable_cardip() {
+  std::string* _s = _internal_mutable_cardip();
+  // @@protoc_insertion_point(field_mutable:stream.ScannerCrtlCfgData.cardIP)
+  return _s;
+}
+inline const std::string& ScannerCrtlCfgData::_internal_cardip() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.cardip_.Get();
+}
+inline void ScannerCrtlCfgData::_internal_set_cardip(const std::string& value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.cardip_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ScannerCrtlCfgData::_internal_mutable_cardip() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  return _impl_.cardip_.Mutable( GetArenaForAllocation());
+}
+inline std::string* ScannerCrtlCfgData::release_cardip() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  // @@protoc_insertion_point(field_release:stream.ScannerCrtlCfgData.cardIP)
+  return _impl_.cardip_.Release();
+}
+inline void ScannerCrtlCfgData::set_allocated_cardip(std::string* value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  _impl_.cardip_.SetAllocated(value, GetArenaForAllocation());
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        if (_impl_.cardip_.IsDefault()) {
+          _impl_.cardip_.Set("", GetArenaForAllocation());
+        }
+  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:stream.ScannerCrtlCfgData.cardIP)
+}
+
+// bool isEnable = 17;
+inline void ScannerCrtlCfgData::clear_isenable() {
+  _impl_.isenable_ = false;
+}
+inline bool ScannerCrtlCfgData::isenable() const {
+  // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.isEnable)
+  return _internal_isenable();
+}
+inline void ScannerCrtlCfgData::set_isenable(bool value) {
+  _internal_set_isenable(value);
+  // @@protoc_insertion_point(field_set:stream.ScannerCrtlCfgData.isEnable)
+}
+inline bool ScannerCrtlCfgData::_internal_isenable() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.isenable_;
+}
+inline void ScannerCrtlCfgData::_internal_set_isenable(bool value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.isenable_ = value;
+}
+
+// bool hadAssign = 18;
+inline void ScannerCrtlCfgData::clear_hadassign() {
+  _impl_.hadassign_ = false;
+}
+inline bool ScannerCrtlCfgData::hadassign() const {
+  // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.hadAssign)
+  return _internal_hadassign();
+}
+inline void ScannerCrtlCfgData::set_hadassign(bool value) {
+  _internal_set_hadassign(value);
+  // @@protoc_insertion_point(field_set:stream.ScannerCrtlCfgData.hadAssign)
+}
+inline bool ScannerCrtlCfgData::_internal_hadassign() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.hadassign_;
+}
+inline void ScannerCrtlCfgData::_internal_set_hadassign(bool value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.hadassign_ = value;
+}
+
+// bool hadMatch = 19;
+inline void ScannerCrtlCfgData::clear_hadmatch() {
+  _impl_.hadmatch_ = false;
+}
+inline bool ScannerCrtlCfgData::hadmatch() const {
+  // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.hadMatch)
+  return _internal_hadmatch();
+}
+inline void ScannerCrtlCfgData::set_hadmatch(bool value) {
+  _internal_set_hadmatch(value);
+  // @@protoc_insertion_point(field_set:stream.ScannerCrtlCfgData.hadMatch)
+}
+inline bool ScannerCrtlCfgData::_internal_hadmatch() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.hadmatch_;
+}
+inline void ScannerCrtlCfgData::_internal_set_hadmatch(bool value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.hadmatch_ = value;
+}
+
+// -------------------------------------------------------------------
+
+// FixPointData
+
+// int32 id = 1;
+inline void FixPointData::clear_id() {
+  _impl_.id_ = 0;
+}
+inline ::int32_t FixPointData::id() const {
+  // @@protoc_insertion_point(field_get:stream.FixPointData.id)
+  return _internal_id();
+}
+inline void FixPointData::set_id(::int32_t value) {
+  _internal_set_id(value);
+  // @@protoc_insertion_point(field_set:stream.FixPointData.id)
+}
+inline ::int32_t FixPointData::_internal_id() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.id_;
+}
+inline void FixPointData::_internal_set_id(::int32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.id_ = value;
+}
+
+// int32 cno = 2;
+inline void FixPointData::clear_cno() {
+  _impl_.cno_ = 0;
+}
+inline ::int32_t FixPointData::cno() const {
+  // @@protoc_insertion_point(field_get:stream.FixPointData.cno)
+  return _internal_cno();
+}
+inline void FixPointData::set_cno(::int32_t value) {
+  _internal_set_cno(value);
+  // @@protoc_insertion_point(field_set:stream.FixPointData.cno)
+}
+inline ::int32_t FixPointData::_internal_cno() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.cno_;
+}
+inline void FixPointData::_internal_set_cno(::int32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.cno_ = value;
+}
+
+// float pointX = 3;
+inline void FixPointData::clear_pointx() {
+  _impl_.pointx_ = 0;
+}
+inline float FixPointData::pointx() const {
+  // @@protoc_insertion_point(field_get:stream.FixPointData.pointX)
+  return _internal_pointx();
+}
+inline void FixPointData::set_pointx(float value) {
+  _internal_set_pointx(value);
+  // @@protoc_insertion_point(field_set:stream.FixPointData.pointX)
+}
+inline float FixPointData::_internal_pointx() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.pointx_;
+}
+inline void FixPointData::_internal_set_pointx(float value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.pointx_ = value;
+}
+
+// float pointY = 4;
+inline void FixPointData::clear_pointy() {
+  _impl_.pointy_ = 0;
+}
+inline float FixPointData::pointy() const {
+  // @@protoc_insertion_point(field_get:stream.FixPointData.pointY)
+  return _internal_pointy();
+}
+inline void FixPointData::set_pointy(float value) {
+  _internal_set_pointy(value);
+  // @@protoc_insertion_point(field_set:stream.FixPointData.pointY)
+}
+inline float FixPointData::_internal_pointy() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.pointy_;
+}
+inline void FixPointData::_internal_set_pointy(float value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.pointy_ = value;
+}
+
+// uint32 duration = 5;
+inline void FixPointData::clear_duration() {
+  _impl_.duration_ = 0u;
+}
+inline ::uint32_t FixPointData::duration() const {
+  // @@protoc_insertion_point(field_get:stream.FixPointData.duration)
+  return _internal_duration();
+}
+inline void FixPointData::set_duration(::uint32_t value) {
+  _internal_set_duration(value);
+  // @@protoc_insertion_point(field_set:stream.FixPointData.duration)
+}
+inline ::uint32_t FixPointData::_internal_duration() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.duration_;
+}
+inline void FixPointData::_internal_set_duration(::uint32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.duration_ = value;
+}
+
+// -------------------------------------------------------------------
+
+// ScanParamCfg
+
+// int32 edgeLevel = 1;
+inline void ScanParamCfg::clear_edgelevel() {
+  _impl_.edgelevel_ = 0;
+}
+inline ::int32_t ScanParamCfg::edgelevel() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.edgeLevel)
+  return _internal_edgelevel();
+}
+inline void ScanParamCfg::set_edgelevel(::int32_t value) {
+  _internal_set_edgelevel(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.edgeLevel)
+}
+inline ::int32_t ScanParamCfg::_internal_edgelevel() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.edgelevel_;
+}
+inline void ScanParamCfg::_internal_set_edgelevel(::int32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.edgelevel_ = value;
+}
+
+// int32 edgeLevelMin = 2;
+inline void ScanParamCfg::clear_edgelevelmin() {
+  _impl_.edgelevelmin_ = 0;
+}
+inline ::int32_t ScanParamCfg::edgelevelmin() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.edgeLevelMin)
+  return _internal_edgelevelmin();
+}
+inline void ScanParamCfg::set_edgelevelmin(::int32_t value) {
+  _internal_set_edgelevelmin(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.edgeLevelMin)
+}
+inline ::int32_t ScanParamCfg::_internal_edgelevelmin() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.edgelevelmin_;
+}
+inline void ScanParamCfg::_internal_set_edgelevelmin(::int32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.edgelevelmin_ = value;
+}
+
+// int32 edgeLevelMax = 3;
+inline void ScanParamCfg::clear_edgelevelmax() {
+  _impl_.edgelevelmax_ = 0;
+}
+inline ::int32_t ScanParamCfg::edgelevelmax() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.edgeLevelMax)
+  return _internal_edgelevelmax();
+}
+inline void ScanParamCfg::set_edgelevelmax(::int32_t value) {
+  _internal_set_edgelevelmax(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.edgeLevelMax)
+}
+inline ::int32_t ScanParamCfg::_internal_edgelevelmax() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.edgelevelmax_;
+}
+inline void ScanParamCfg::_internal_set_edgelevelmax(::int32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.edgelevelmax_ = value;
+}
+
+// uint32 jumpDelay = 4;
+inline void ScanParamCfg::clear_jumpdelay() {
+  _impl_.jumpdelay_ = 0u;
+}
+inline ::uint32_t ScanParamCfg::jumpdelay() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.jumpDelay)
+  return _internal_jumpdelay();
+}
+inline void ScanParamCfg::set_jumpdelay(::uint32_t value) {
+  _internal_set_jumpdelay(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.jumpDelay)
+}
+inline ::uint32_t ScanParamCfg::_internal_jumpdelay() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.jumpdelay_;
+}
+inline void ScanParamCfg::_internal_set_jumpdelay(::uint32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.jumpdelay_ = value;
+}
+
+// uint32 jumpDelayMin = 5;
+inline void ScanParamCfg::clear_jumpdelaymin() {
+  _impl_.jumpdelaymin_ = 0u;
+}
+inline ::uint32_t ScanParamCfg::jumpdelaymin() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.jumpDelayMin)
+  return _internal_jumpdelaymin();
+}
+inline void ScanParamCfg::set_jumpdelaymin(::uint32_t value) {
+  _internal_set_jumpdelaymin(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.jumpDelayMin)
+}
+inline ::uint32_t ScanParamCfg::_internal_jumpdelaymin() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.jumpdelaymin_;
+}
+inline void ScanParamCfg::_internal_set_jumpdelaymin(::uint32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.jumpdelaymin_ = value;
+}
+
+// uint32 jumpDelayMax = 6;
+inline void ScanParamCfg::clear_jumpdelaymax() {
+  _impl_.jumpdelaymax_ = 0u;
+}
+inline ::uint32_t ScanParamCfg::jumpdelaymax() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.jumpDelayMax)
+  return _internal_jumpdelaymax();
+}
+inline void ScanParamCfg::set_jumpdelaymax(::uint32_t value) {
+  _internal_set_jumpdelaymax(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.jumpDelayMax)
+}
+inline ::uint32_t ScanParamCfg::_internal_jumpdelaymax() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.jumpdelaymax_;
+}
+inline void ScanParamCfg::_internal_set_jumpdelaymax(::uint32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.jumpdelaymax_ = value;
+}
+
+// uint32 scanDelay = 7;
+inline void ScanParamCfg::clear_scandelay() {
+  _impl_.scandelay_ = 0u;
+}
+inline ::uint32_t ScanParamCfg::scandelay() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.scanDelay)
+  return _internal_scandelay();
+}
+inline void ScanParamCfg::set_scandelay(::uint32_t value) {
+  _internal_set_scandelay(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.scanDelay)
+}
+inline ::uint32_t ScanParamCfg::_internal_scandelay() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.scandelay_;
+}
+inline void ScanParamCfg::_internal_set_scandelay(::uint32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.scandelay_ = value;
+}
+
+// uint32 scanDelayMin = 8;
+inline void ScanParamCfg::clear_scandelaymin() {
+  _impl_.scandelaymin_ = 0u;
+}
+inline ::uint32_t ScanParamCfg::scandelaymin() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.scanDelayMin)
+  return _internal_scandelaymin();
+}
+inline void ScanParamCfg::set_scandelaymin(::uint32_t value) {
+  _internal_set_scandelaymin(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.scanDelayMin)
+}
+inline ::uint32_t ScanParamCfg::_internal_scandelaymin() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.scandelaymin_;
+}
+inline void ScanParamCfg::_internal_set_scandelaymin(::uint32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.scandelaymin_ = value;
+}
+
+// uint32 scanDelayMax = 9;
+inline void ScanParamCfg::clear_scandelaymax() {
+  _impl_.scandelaymax_ = 0u;
+}
+inline ::uint32_t ScanParamCfg::scandelaymax() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.scanDelayMax)
+  return _internal_scandelaymax();
+}
+inline void ScanParamCfg::set_scandelaymax(::uint32_t value) {
+  _internal_set_scandelaymax(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.scanDelayMax)
+}
+inline ::uint32_t ScanParamCfg::_internal_scandelaymax() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.scandelaymax_;
+}
+inline void ScanParamCfg::_internal_set_scandelaymax(::uint32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.scandelaymax_ = value;
+}
+
+// uint32 polygonDelay = 10;
+inline void ScanParamCfg::clear_polygondelay() {
+  _impl_.polygondelay_ = 0u;
+}
+inline ::uint32_t ScanParamCfg::polygondelay() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.polygonDelay)
+  return _internal_polygondelay();
+}
+inline void ScanParamCfg::set_polygondelay(::uint32_t value) {
+  _internal_set_polygondelay(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.polygonDelay)
+}
+inline ::uint32_t ScanParamCfg::_internal_polygondelay() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.polygondelay_;
+}
+inline void ScanParamCfg::_internal_set_polygondelay(::uint32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.polygondelay_ = value;
+}
+
+// uint32 polygonDelayMin = 11;
+inline void ScanParamCfg::clear_polygondelaymin() {
+  _impl_.polygondelaymin_ = 0u;
+}
+inline ::uint32_t ScanParamCfg::polygondelaymin() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.polygonDelayMin)
+  return _internal_polygondelaymin();
+}
+inline void ScanParamCfg::set_polygondelaymin(::uint32_t value) {
+  _internal_set_polygondelaymin(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.polygonDelayMin)
+}
+inline ::uint32_t ScanParamCfg::_internal_polygondelaymin() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.polygondelaymin_;
+}
+inline void ScanParamCfg::_internal_set_polygondelaymin(::uint32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.polygondelaymin_ = value;
+}
+
+// uint32 polygonDelayMax = 12;
+inline void ScanParamCfg::clear_polygondelaymax() {
+  _impl_.polygondelaymax_ = 0u;
+}
+inline ::uint32_t ScanParamCfg::polygondelaymax() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.polygonDelayMax)
+  return _internal_polygondelaymax();
+}
+inline void ScanParamCfg::set_polygondelaymax(::uint32_t value) {
+  _internal_set_polygondelaymax(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.polygonDelayMax)
+}
+inline ::uint32_t ScanParamCfg::_internal_polygondelaymax() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.polygondelaymax_;
+}
+inline void ScanParamCfg::_internal_set_polygondelaymax(::uint32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.polygondelaymax_ = value;
+}
+
+// int64 laseroffDelay = 13;
+inline void ScanParamCfg::clear_laseroffdelay() {
+  _impl_.laseroffdelay_ = ::int64_t{0};
+}
+inline ::int64_t ScanParamCfg::laseroffdelay() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.laseroffDelay)
+  return _internal_laseroffdelay();
+}
+inline void ScanParamCfg::set_laseroffdelay(::int64_t value) {
+  _internal_set_laseroffdelay(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.laseroffDelay)
+}
+inline ::int64_t ScanParamCfg::_internal_laseroffdelay() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.laseroffdelay_;
+}
+inline void ScanParamCfg::_internal_set_laseroffdelay(::int64_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.laseroffdelay_ = value;
+}
+
+// int64 laseroffDelayMin = 14;
+inline void ScanParamCfg::clear_laseroffdelaymin() {
+  _impl_.laseroffdelaymin_ = ::int64_t{0};
+}
+inline ::int64_t ScanParamCfg::laseroffdelaymin() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.laseroffDelayMin)
+  return _internal_laseroffdelaymin();
+}
+inline void ScanParamCfg::set_laseroffdelaymin(::int64_t value) {
+  _internal_set_laseroffdelaymin(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.laseroffDelayMin)
+}
+inline ::int64_t ScanParamCfg::_internal_laseroffdelaymin() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.laseroffdelaymin_;
+}
+inline void ScanParamCfg::_internal_set_laseroffdelaymin(::int64_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.laseroffdelaymin_ = value;
+}
+
+// int64 laseroffDelayMax = 15;
+inline void ScanParamCfg::clear_laseroffdelaymax() {
+  _impl_.laseroffdelaymax_ = ::int64_t{0};
+}
+inline ::int64_t ScanParamCfg::laseroffdelaymax() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.laseroffDelayMax)
+  return _internal_laseroffdelaymax();
+}
+inline void ScanParamCfg::set_laseroffdelaymax(::int64_t value) {
+  _internal_set_laseroffdelaymax(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.laseroffDelayMax)
+}
+inline ::int64_t ScanParamCfg::_internal_laseroffdelaymax() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.laseroffdelaymax_;
+}
+inline void ScanParamCfg::_internal_set_laseroffdelaymax(::int64_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.laseroffdelaymax_ = value;
+}
+
+// int64 laseronDelay = 16;
+inline void ScanParamCfg::clear_laserondelay() {
+  _impl_.laserondelay_ = ::int64_t{0};
+}
+inline ::int64_t ScanParamCfg::laserondelay() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.laseronDelay)
+  return _internal_laserondelay();
+}
+inline void ScanParamCfg::set_laserondelay(::int64_t value) {
+  _internal_set_laserondelay(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.laseronDelay)
+}
+inline ::int64_t ScanParamCfg::_internal_laserondelay() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.laserondelay_;
+}
+inline void ScanParamCfg::_internal_set_laserondelay(::int64_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.laserondelay_ = value;
+}
+
+// int64 laseronDelayMin = 17;
+inline void ScanParamCfg::clear_laserondelaymin() {
+  _impl_.laserondelaymin_ = ::int64_t{0};
+}
+inline ::int64_t ScanParamCfg::laserondelaymin() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.laseronDelayMin)
+  return _internal_laserondelaymin();
+}
+inline void ScanParamCfg::set_laserondelaymin(::int64_t value) {
+  _internal_set_laserondelaymin(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.laseronDelayMin)
+}
+inline ::int64_t ScanParamCfg::_internal_laserondelaymin() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.laserondelaymin_;
+}
+inline void ScanParamCfg::_internal_set_laserondelaymin(::int64_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.laserondelaymin_ = value;
+}
+
+// int64 laseronDelayMax = 18;
+inline void ScanParamCfg::clear_laserondelaymax() {
+  _impl_.laserondelaymax_ = ::int64_t{0};
+}
+inline ::int64_t ScanParamCfg::laserondelaymax() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.laseronDelayMax)
+  return _internal_laserondelaymax();
+}
+inline void ScanParamCfg::set_laserondelaymax(::int64_t value) {
+  _internal_set_laserondelaymax(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.laseronDelayMax)
+}
+inline ::int64_t ScanParamCfg::_internal_laserondelaymax() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.laserondelaymax_;
+}
+inline void ScanParamCfg::_internal_set_laserondelaymax(::int64_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.laserondelaymax_ = value;
+}
+
+// uint32 minJumpDelay = 19;
+inline void ScanParamCfg::clear_minjumpdelay() {
+  _impl_.minjumpdelay_ = 0u;
+}
+inline ::uint32_t ScanParamCfg::minjumpdelay() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.minJumpDelay)
+  return _internal_minjumpdelay();
+}
+inline void ScanParamCfg::set_minjumpdelay(::uint32_t value) {
+  _internal_set_minjumpdelay(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.minJumpDelay)
+}
+inline ::uint32_t ScanParamCfg::_internal_minjumpdelay() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.minjumpdelay_;
+}
+inline void ScanParamCfg::_internal_set_minjumpdelay(::uint32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.minjumpdelay_ = value;
+}
+
+// uint32 minJumpDelayMin = 20;
+inline void ScanParamCfg::clear_minjumpdelaymin() {
+  _impl_.minjumpdelaymin_ = 0u;
+}
+inline ::uint32_t ScanParamCfg::minjumpdelaymin() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.minJumpDelayMin)
+  return _internal_minjumpdelaymin();
+}
+inline void ScanParamCfg::set_minjumpdelaymin(::uint32_t value) {
+  _internal_set_minjumpdelaymin(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.minJumpDelayMin)
+}
+inline ::uint32_t ScanParamCfg::_internal_minjumpdelaymin() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.minjumpdelaymin_;
+}
+inline void ScanParamCfg::_internal_set_minjumpdelaymin(::uint32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.minjumpdelaymin_ = value;
+}
+
+// uint32 minJumpDelayMax = 21;
+inline void ScanParamCfg::clear_minjumpdelaymax() {
+  _impl_.minjumpdelaymax_ = 0u;
+}
+inline ::uint32_t ScanParamCfg::minjumpdelaymax() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.minJumpDelayMax)
+  return _internal_minjumpdelaymax();
+}
+inline void ScanParamCfg::set_minjumpdelaymax(::uint32_t value) {
+  _internal_set_minjumpdelaymax(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.minJumpDelayMax)
+}
+inline ::uint32_t ScanParamCfg::_internal_minjumpdelaymax() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.minjumpdelaymax_;
+}
+inline void ScanParamCfg::_internal_set_minjumpdelaymax(::uint32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.minjumpdelaymax_ = value;
+}
+
+// uint32 jumpLengthLimit = 22;
+inline void ScanParamCfg::clear_jumplengthlimit() {
+  _impl_.jumplengthlimit_ = 0u;
+}
+inline ::uint32_t ScanParamCfg::jumplengthlimit() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.jumpLengthLimit)
+  return _internal_jumplengthlimit();
+}
+inline void ScanParamCfg::set_jumplengthlimit(::uint32_t value) {
+  _internal_set_jumplengthlimit(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.jumpLengthLimit)
+}
+inline ::uint32_t ScanParamCfg::_internal_jumplengthlimit() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.jumplengthlimit_;
+}
+inline void ScanParamCfg::_internal_set_jumplengthlimit(::uint32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.jumplengthlimit_ = value;
+}
+
+// uint32 jumpLengthLimitMin = 23;
+inline void ScanParamCfg::clear_jumplengthlimitmin() {
+  _impl_.jumplengthlimitmin_ = 0u;
+}
+inline ::uint32_t ScanParamCfg::jumplengthlimitmin() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.jumpLengthLimitMin)
+  return _internal_jumplengthlimitmin();
+}
+inline void ScanParamCfg::set_jumplengthlimitmin(::uint32_t value) {
+  _internal_set_jumplengthlimitmin(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.jumpLengthLimitMin)
+}
+inline ::uint32_t ScanParamCfg::_internal_jumplengthlimitmin() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.jumplengthlimitmin_;
+}
+inline void ScanParamCfg::_internal_set_jumplengthlimitmin(::uint32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.jumplengthlimitmin_ = value;
+}
+
+// uint32 jumpLengthLimitMax = 24;
+inline void ScanParamCfg::clear_jumplengthlimitmax() {
+  _impl_.jumplengthlimitmax_ = 0u;
+}
+inline ::uint32_t ScanParamCfg::jumplengthlimitmax() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.jumpLengthLimitMax)
+  return _internal_jumplengthlimitmax();
+}
+inline void ScanParamCfg::set_jumplengthlimitmax(::uint32_t value) {
+  _internal_set_jumplengthlimitmax(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.jumpLengthLimitMax)
+}
+inline ::uint32_t ScanParamCfg::_internal_jumplengthlimitmax() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.jumplengthlimitmax_;
+}
+inline void ScanParamCfg::_internal_set_jumplengthlimitmax(::uint32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.jumplengthlimitmax_ = value;
+}
+
+// double jumpSpeed = 25;
+inline void ScanParamCfg::clear_jumpspeed() {
+  _impl_.jumpspeed_ = 0;
+}
+inline double ScanParamCfg::jumpspeed() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.jumpSpeed)
+  return _internal_jumpspeed();
+}
+inline void ScanParamCfg::set_jumpspeed(double value) {
+  _internal_set_jumpspeed(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.jumpSpeed)
+}
+inline double ScanParamCfg::_internal_jumpspeed() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.jumpspeed_;
+}
+inline void ScanParamCfg::_internal_set_jumpspeed(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.jumpspeed_ = value;
+}
+
+// double jumpSpeedMin = 26;
+inline void ScanParamCfg::clear_jumpspeedmin() {
+  _impl_.jumpspeedmin_ = 0;
+}
+inline double ScanParamCfg::jumpspeedmin() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.jumpSpeedMin)
+  return _internal_jumpspeedmin();
+}
+inline void ScanParamCfg::set_jumpspeedmin(double value) {
+  _internal_set_jumpspeedmin(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.jumpSpeedMin)
+}
+inline double ScanParamCfg::_internal_jumpspeedmin() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.jumpspeedmin_;
+}
+inline void ScanParamCfg::_internal_set_jumpspeedmin(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.jumpspeedmin_ = value;
+}
+
+// double jumpSpeedMax = 27;
+inline void ScanParamCfg::clear_jumpspeedmax() {
+  _impl_.jumpspeedmax_ = 0;
+}
+inline double ScanParamCfg::jumpspeedmax() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.jumpSpeedMax)
+  return _internal_jumpspeedmax();
+}
+inline void ScanParamCfg::set_jumpspeedmax(double value) {
+  _internal_set_jumpspeedmax(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.jumpSpeedMax)
+}
+inline double ScanParamCfg::_internal_jumpspeedmax() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.jumpspeedmax_;
+}
+inline void ScanParamCfg::_internal_set_jumpspeedmax(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.jumpspeedmax_ = value;
+}
+
+// double markSpeed = 28;
+inline void ScanParamCfg::clear_markspeed() {
+  _impl_.markspeed_ = 0;
+}
+inline double ScanParamCfg::markspeed() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.markSpeed)
+  return _internal_markspeed();
+}
+inline void ScanParamCfg::set_markspeed(double value) {
+  _internal_set_markspeed(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.markSpeed)
+}
+inline double ScanParamCfg::_internal_markspeed() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.markspeed_;
+}
+inline void ScanParamCfg::_internal_set_markspeed(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.markspeed_ = value;
+}
+
+// double markSpeedMin = 29;
+inline void ScanParamCfg::clear_markspeedmin() {
+  _impl_.markspeedmin_ = 0;
+}
+inline double ScanParamCfg::markspeedmin() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.markSpeedMin)
+  return _internal_markspeedmin();
+}
+inline void ScanParamCfg::set_markspeedmin(double value) {
+  _internal_set_markspeedmin(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.markSpeedMin)
+}
+inline double ScanParamCfg::_internal_markspeedmin() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.markspeedmin_;
+}
+inline void ScanParamCfg::_internal_set_markspeedmin(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.markspeedmin_ = value;
+}
+
+// double markSpeedMax = 30;
+inline void ScanParamCfg::clear_markspeedmax() {
+  _impl_.markspeedmax_ = 0;
+}
+inline double ScanParamCfg::markspeedmax() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.markSpeedMax)
+  return _internal_markspeedmax();
+}
+inline void ScanParamCfg::set_markspeedmax(double value) {
+  _internal_set_markspeedmax(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.markSpeedMax)
+}
+inline double ScanParamCfg::_internal_markspeedmax() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.markspeedmax_;
+}
+inline void ScanParamCfg::_internal_set_markspeedmax(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.markspeedmax_ = value;
+}
+
+// -------------------------------------------------------------------
+
+// CorrectParamCfg
+
+// double xmeasureMin = 1;
+inline void CorrectParamCfg::clear_xmeasuremin() {
+  _impl_.xmeasuremin_ = 0;
+}
+inline double CorrectParamCfg::xmeasuremin() const {
+  // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.xmeasureMin)
+  return _internal_xmeasuremin();
+}
+inline void CorrectParamCfg::set_xmeasuremin(double value) {
+  _internal_set_xmeasuremin(value);
+  // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.xmeasureMin)
+}
+inline double CorrectParamCfg::_internal_xmeasuremin() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.xmeasuremin_;
+}
+inline void CorrectParamCfg::_internal_set_xmeasuremin(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.xmeasuremin_ = value;
+}
+
+// double xmeasureMax = 2;
+inline void CorrectParamCfg::clear_xmeasuremax() {
+  _impl_.xmeasuremax_ = 0;
+}
+inline double CorrectParamCfg::xmeasuremax() const {
+  // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.xmeasureMax)
+  return _internal_xmeasuremax();
+}
+inline void CorrectParamCfg::set_xmeasuremax(double value) {
+  _internal_set_xmeasuremax(value);
+  // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.xmeasureMax)
+}
+inline double CorrectParamCfg::_internal_xmeasuremax() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.xmeasuremax_;
+}
+inline void CorrectParamCfg::_internal_set_xmeasuremax(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.xmeasuremax_ = value;
+}
+
+// double ymeasureMin = 3;
+inline void CorrectParamCfg::clear_ymeasuremin() {
+  _impl_.ymeasuremin_ = 0;
+}
+inline double CorrectParamCfg::ymeasuremin() const {
+  // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.ymeasureMin)
+  return _internal_ymeasuremin();
+}
+inline void CorrectParamCfg::set_ymeasuremin(double value) {
+  _internal_set_ymeasuremin(value);
+  // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.ymeasureMin)
+}
+inline double CorrectParamCfg::_internal_ymeasuremin() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.ymeasuremin_;
+}
+inline void CorrectParamCfg::_internal_set_ymeasuremin(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.ymeasuremin_ = value;
+}
+
+// double ymeasureMax = 4;
+inline void CorrectParamCfg::clear_ymeasuremax() {
+  _impl_.ymeasuremax_ = 0;
+}
+inline double CorrectParamCfg::ymeasuremax() const {
+  // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.ymeasureMax)
+  return _internal_ymeasuremax();
+}
+inline void CorrectParamCfg::set_ymeasuremax(double value) {
+  _internal_set_ymeasuremax(value);
+  // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.ymeasureMax)
+}
+inline double CorrectParamCfg::_internal_ymeasuremax() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.ymeasuremax_;
+}
+inline void CorrectParamCfg::_internal_set_ymeasuremax(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.ymeasuremax_ = value;
+}
+
+// double xposfix = 5;
+inline void CorrectParamCfg::clear_xposfix() {
+  _impl_.xposfix_ = 0;
+}
+inline double CorrectParamCfg::xposfix() const {
+  // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.xposfix)
+  return _internal_xposfix();
+}
+inline void CorrectParamCfg::set_xposfix(double value) {
+  _internal_set_xposfix(value);
+  // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.xposfix)
+}
+inline double CorrectParamCfg::_internal_xposfix() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.xposfix_;
+}
+inline void CorrectParamCfg::_internal_set_xposfix(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.xposfix_ = value;
+}
+
+// double yposfix = 6;
+inline void CorrectParamCfg::clear_yposfix() {
+  _impl_.yposfix_ = 0;
+}
+inline double CorrectParamCfg::yposfix() const {
+  // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.yposfix)
+  return _internal_yposfix();
+}
+inline void CorrectParamCfg::set_yposfix(double value) {
+  _internal_set_yposfix(value);
+  // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.yposfix)
+}
+inline double CorrectParamCfg::_internal_yposfix() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.yposfix_;
+}
+inline void CorrectParamCfg::_internal_set_yposfix(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.yposfix_ = value;
+}
+
+// double scanAngle = 7;
+inline void CorrectParamCfg::clear_scanangle() {
+  _impl_.scanangle_ = 0;
+}
+inline double CorrectParamCfg::scanangle() const {
+  // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.scanAngle)
+  return _internal_scanangle();
+}
+inline void CorrectParamCfg::set_scanangle(double value) {
+  _internal_set_scanangle(value);
+  // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.scanAngle)
+}
+inline double CorrectParamCfg::_internal_scanangle() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.scanangle_;
+}
+inline void CorrectParamCfg::_internal_set_scanangle(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.scanangle_ = value;
+}
+
+// double scanAngleMin = 8;
+inline void CorrectParamCfg::clear_scananglemin() {
+  _impl_.scananglemin_ = 0;
+}
+inline double CorrectParamCfg::scananglemin() const {
+  // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.scanAngleMin)
+  return _internal_scananglemin();
+}
+inline void CorrectParamCfg::set_scananglemin(double value) {
+  _internal_set_scananglemin(value);
+  // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.scanAngleMin)
+}
+inline double CorrectParamCfg::_internal_scananglemin() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.scananglemin_;
+}
+inline void CorrectParamCfg::_internal_set_scananglemin(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.scananglemin_ = value;
+}
+
+// double scanAngleMax = 9;
+inline void CorrectParamCfg::clear_scananglemax() {
+  _impl_.scananglemax_ = 0;
+}
+inline double CorrectParamCfg::scananglemax() const {
+  // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.scanAngleMax)
+  return _internal_scananglemax();
+}
+inline void CorrectParamCfg::set_scananglemax(double value) {
+  _internal_set_scananglemax(value);
+  // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.scanAngleMax)
+}
+inline double CorrectParamCfg::_internal_scananglemax() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.scananglemax_;
+}
+inline void CorrectParamCfg::_internal_set_scananglemax(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.scananglemax_ = value;
+}
+
+// double fixAngle = 10;
+inline void CorrectParamCfg::clear_fixangle() {
+  _impl_.fixangle_ = 0;
+}
+inline double CorrectParamCfg::fixangle() const {
+  // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.fixAngle)
+  return _internal_fixangle();
+}
+inline void CorrectParamCfg::set_fixangle(double value) {
+  _internal_set_fixangle(value);
+  // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.fixAngle)
+}
+inline double CorrectParamCfg::_internal_fixangle() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.fixangle_;
+}
+inline void CorrectParamCfg::_internal_set_fixangle(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.fixangle_ = value;
+}
+
+// double fixAngleMin = 11;
+inline void CorrectParamCfg::clear_fixanglemin() {
+  _impl_.fixanglemin_ = 0;
+}
+inline double CorrectParamCfg::fixanglemin() const {
+  // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.fixAngleMin)
+  return _internal_fixanglemin();
+}
+inline void CorrectParamCfg::set_fixanglemin(double value) {
+  _internal_set_fixanglemin(value);
+  // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.fixAngleMin)
+}
+inline double CorrectParamCfg::_internal_fixanglemin() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.fixanglemin_;
+}
+inline void CorrectParamCfg::_internal_set_fixanglemin(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.fixanglemin_ = value;
+}
+
+// double fixAngleMax = 12;
+inline void CorrectParamCfg::clear_fixanglemax() {
+  _impl_.fixanglemax_ = 0;
+}
+inline double CorrectParamCfg::fixanglemax() const {
+  // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.fixAngleMax)
+  return _internal_fixanglemax();
+}
+inline void CorrectParamCfg::set_fixanglemax(double value) {
+  _internal_set_fixanglemax(value);
+  // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.fixAngleMax)
+}
+inline double CorrectParamCfg::_internal_fixanglemax() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.fixanglemax_;
+}
+inline void CorrectParamCfg::_internal_set_fixanglemax(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.fixanglemax_ = value;
+}
+
+// double xcorrect = 13;
+inline void CorrectParamCfg::clear_xcorrect() {
+  _impl_.xcorrect_ = 0;
+}
+inline double CorrectParamCfg::xcorrect() const {
+  // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.xcorrect)
+  return _internal_xcorrect();
+}
+inline void CorrectParamCfg::set_xcorrect(double value) {
+  _internal_set_xcorrect(value);
+  // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.xcorrect)
+}
+inline double CorrectParamCfg::_internal_xcorrect() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.xcorrect_;
+}
+inline void CorrectParamCfg::_internal_set_xcorrect(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.xcorrect_ = value;
+}
+
+// double ycorrect = 14;
+inline void CorrectParamCfg::clear_ycorrect() {
+  _impl_.ycorrect_ = 0;
+}
+inline double CorrectParamCfg::ycorrect() const {
+  // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.ycorrect)
+  return _internal_ycorrect();
+}
+inline void CorrectParamCfg::set_ycorrect(double value) {
+  _internal_set_ycorrect(value);
+  // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.ycorrect)
+}
+inline double CorrectParamCfg::_internal_ycorrect() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.ycorrect_;
+}
+inline void CorrectParamCfg::_internal_set_ycorrect(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.ycorrect_ = value;
+}
+
+// double xcorrectMin = 15;
+inline void CorrectParamCfg::clear_xcorrectmin() {
+  _impl_.xcorrectmin_ = 0;
+}
+inline double CorrectParamCfg::xcorrectmin() const {
+  // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.xcorrectMin)
+  return _internal_xcorrectmin();
+}
+inline void CorrectParamCfg::set_xcorrectmin(double value) {
+  _internal_set_xcorrectmin(value);
+  // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.xcorrectMin)
+}
+inline double CorrectParamCfg::_internal_xcorrectmin() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.xcorrectmin_;
+}
+inline void CorrectParamCfg::_internal_set_xcorrectmin(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.xcorrectmin_ = value;
+}
+
+// double xcorrectMax = 16;
+inline void CorrectParamCfg::clear_xcorrectmax() {
+  _impl_.xcorrectmax_ = 0;
+}
+inline double CorrectParamCfg::xcorrectmax() const {
+  // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.xcorrectMax)
+  return _internal_xcorrectmax();
+}
+inline void CorrectParamCfg::set_xcorrectmax(double value) {
+  _internal_set_xcorrectmax(value);
+  // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.xcorrectMax)
+}
+inline double CorrectParamCfg::_internal_xcorrectmax() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.xcorrectmax_;
+}
+inline void CorrectParamCfg::_internal_set_xcorrectmax(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.xcorrectmax_ = value;
+}
+
+// double ycorrectMin = 17;
+inline void CorrectParamCfg::clear_ycorrectmin() {
+  _impl_.ycorrectmin_ = 0;
+}
+inline double CorrectParamCfg::ycorrectmin() const {
+  // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.ycorrectMin)
+  return _internal_ycorrectmin();
+}
+inline void CorrectParamCfg::set_ycorrectmin(double value) {
+  _internal_set_ycorrectmin(value);
+  // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.ycorrectMin)
+}
+inline double CorrectParamCfg::_internal_ycorrectmin() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.ycorrectmin_;
+}
+inline void CorrectParamCfg::_internal_set_ycorrectmin(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.ycorrectmin_ = value;
+}
+
+// double ycorrectMax = 18;
+inline void CorrectParamCfg::clear_ycorrectmax() {
+  _impl_.ycorrectmax_ = 0;
+}
+inline double CorrectParamCfg::ycorrectmax() const {
+  // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.ycorrectMax)
+  return _internal_ycorrectmax();
+}
+inline void CorrectParamCfg::set_ycorrectmax(double value) {
+  _internal_set_ycorrectmax(value);
+  // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.ycorrectMax)
+}
+inline double CorrectParamCfg::_internal_ycorrectmax() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.ycorrectmax_;
+}
+inline void CorrectParamCfg::_internal_set_ycorrectmax(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.ycorrectmax_ = value;
+}
+
+// double realXOffset = 19;
+inline void CorrectParamCfg::clear_realxoffset() {
+  _impl_.realxoffset_ = 0;
+}
+inline double CorrectParamCfg::realxoffset() const {
+  // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.realXOffset)
+  return _internal_realxoffset();
+}
+inline void CorrectParamCfg::set_realxoffset(double value) {
+  _internal_set_realxoffset(value);
+  // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.realXOffset)
+}
+inline double CorrectParamCfg::_internal_realxoffset() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.realxoffset_;
+}
+inline void CorrectParamCfg::_internal_set_realxoffset(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.realxoffset_ = value;
+}
+
+// double realYOffset = 20;
+inline void CorrectParamCfg::clear_realyoffset() {
+  _impl_.realyoffset_ = 0;
+}
+inline double CorrectParamCfg::realyoffset() const {
+  // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.realYOffset)
+  return _internal_realyoffset();
+}
+inline void CorrectParamCfg::set_realyoffset(double value) {
+  _internal_set_realyoffset(value);
+  // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.realYOffset)
+}
+inline double CorrectParamCfg::_internal_realyoffset() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.realyoffset_;
+}
+inline void CorrectParamCfg::_internal_set_realyoffset(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.realyoffset_ = value;
+}
+
+// double factorK = 21;
+inline void CorrectParamCfg::clear_factork() {
+  _impl_.factork_ = 0;
+}
+inline double CorrectParamCfg::factork() const {
+  // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.factorK)
+  return _internal_factork();
+}
+inline void CorrectParamCfg::set_factork(double value) {
+  _internal_set_factork(value);
+  // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.factorK)
+}
+inline double CorrectParamCfg::_internal_factork() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.factork_;
+}
+inline void CorrectParamCfg::_internal_set_factork(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.factork_ = value;
+}
+
+// bool isCorrectFile3D = 22;
+inline void CorrectParamCfg::clear_iscorrectfile3d() {
+  _impl_.iscorrectfile3d_ = false;
+}
+inline bool CorrectParamCfg::iscorrectfile3d() const {
+  // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.isCorrectFile3D)
+  return _internal_iscorrectfile3d();
+}
+inline void CorrectParamCfg::set_iscorrectfile3d(bool value) {
+  _internal_set_iscorrectfile3d(value);
+  // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.isCorrectFile3D)
+}
+inline bool CorrectParamCfg::_internal_iscorrectfile3d() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.iscorrectfile3d_;
+}
+inline void CorrectParamCfg::_internal_set_iscorrectfile3d(bool value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.iscorrectfile3d_ = value;
+}
+
+// bool isDynamicFocus = 23;
+inline void CorrectParamCfg::clear_isdynamicfocus() {
+  _impl_.isdynamicfocus_ = false;
+}
+inline bool CorrectParamCfg::isdynamicfocus() const {
+  // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.isDynamicFocus)
+  return _internal_isdynamicfocus();
+}
+inline void CorrectParamCfg::set_isdynamicfocus(bool value) {
+  _internal_set_isdynamicfocus(value);
+  // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.isDynamicFocus)
+}
+inline bool CorrectParamCfg::_internal_isdynamicfocus() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.isdynamicfocus_;
+}
+inline void CorrectParamCfg::_internal_set_isdynamicfocus(bool value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.isdynamicfocus_ = value;
+}
+
+// double defocusRatio = 24;
+inline void CorrectParamCfg::clear_defocusratio() {
+  _impl_.defocusratio_ = 0;
+}
+inline double CorrectParamCfg::defocusratio() const {
+  // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.defocusRatio)
+  return _internal_defocusratio();
+}
+inline void CorrectParamCfg::set_defocusratio(double value) {
+  _internal_set_defocusratio(value);
+  // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.defocusRatio)
+}
+inline double CorrectParamCfg::_internal_defocusratio() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.defocusratio_;
+}
+inline void CorrectParamCfg::_internal_set_defocusratio(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.defocusratio_ = value;
+}
+
+// double defocusRatioMin = 25;
+inline void CorrectParamCfg::clear_defocusratiomin() {
+  _impl_.defocusratiomin_ = 0;
+}
+inline double CorrectParamCfg::defocusratiomin() const {
+  // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.defocusRatioMin)
+  return _internal_defocusratiomin();
+}
+inline void CorrectParamCfg::set_defocusratiomin(double value) {
+  _internal_set_defocusratiomin(value);
+  // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.defocusRatioMin)
+}
+inline double CorrectParamCfg::_internal_defocusratiomin() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.defocusratiomin_;
+}
+inline void CorrectParamCfg::_internal_set_defocusratiomin(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.defocusratiomin_ = value;
+}
+
+// double defocusRatioMax = 26;
+inline void CorrectParamCfg::clear_defocusratiomax() {
+  _impl_.defocusratiomax_ = 0;
+}
+inline double CorrectParamCfg::defocusratiomax() const {
+  // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.defocusRatioMax)
+  return _internal_defocusratiomax();
+}
+inline void CorrectParamCfg::set_defocusratiomax(double value) {
+  _internal_set_defocusratiomax(value);
+  // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.defocusRatioMax)
+}
+inline double CorrectParamCfg::_internal_defocusratiomax() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.defocusratiomax_;
+}
+inline void CorrectParamCfg::_internal_set_defocusratiomax(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.defocusratiomax_ = value;
+}
+
+// -------------------------------------------------------------------
+
+// ScanTestCfg
+
+// int32 debugShape = 1;
+inline void ScanTestCfg::clear_debugshape() {
+  _impl_.debugshape_ = 0;
+}
+inline ::int32_t ScanTestCfg::debugshape() const {
+  // @@protoc_insertion_point(field_get:stream.ScanTestCfg.debugShape)
+  return _internal_debugshape();
+}
+inline void ScanTestCfg::set_debugshape(::int32_t value) {
+  _internal_set_debugshape(value);
+  // @@protoc_insertion_point(field_set:stream.ScanTestCfg.debugShape)
+}
+inline ::int32_t ScanTestCfg::_internal_debugshape() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.debugshape_;
+}
+inline void ScanTestCfg::_internal_set_debugshape(::int32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.debugshape_ = value;
+}
+
+// int32 shapeSize = 2;
+inline void ScanTestCfg::clear_shapesize() {
+  _impl_.shapesize_ = 0;
+}
+inline ::int32_t ScanTestCfg::shapesize() const {
+  // @@protoc_insertion_point(field_get:stream.ScanTestCfg.shapeSize)
+  return _internal_shapesize();
+}
+inline void ScanTestCfg::set_shapesize(::int32_t value) {
+  _internal_set_shapesize(value);
+  // @@protoc_insertion_point(field_set:stream.ScanTestCfg.shapeSize)
+}
+inline ::int32_t ScanTestCfg::_internal_shapesize() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.shapesize_;
+}
+inline void ScanTestCfg::_internal_set_shapesize(::int32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.shapesize_ = value;
+}
+
+// int32 shapeSizeMin = 3;
+inline void ScanTestCfg::clear_shapesizemin() {
+  _impl_.shapesizemin_ = 0;
+}
+inline ::int32_t ScanTestCfg::shapesizemin() const {
+  // @@protoc_insertion_point(field_get:stream.ScanTestCfg.shapeSizeMin)
+  return _internal_shapesizemin();
+}
+inline void ScanTestCfg::set_shapesizemin(::int32_t value) {
+  _internal_set_shapesizemin(value);
+  // @@protoc_insertion_point(field_set:stream.ScanTestCfg.shapeSizeMin)
+}
+inline ::int32_t ScanTestCfg::_internal_shapesizemin() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.shapesizemin_;
+}
+inline void ScanTestCfg::_internal_set_shapesizemin(::int32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.shapesizemin_ = value;
+}
+
+// int32 shape_size_max = 4;
+inline void ScanTestCfg::clear_shape_size_max() {
+  _impl_.shape_size_max_ = 0;
+}
+inline ::int32_t ScanTestCfg::shape_size_max() const {
+  // @@protoc_insertion_point(field_get:stream.ScanTestCfg.shape_size_max)
+  return _internal_shape_size_max();
+}
+inline void ScanTestCfg::set_shape_size_max(::int32_t value) {
+  _internal_set_shape_size_max(value);
+  // @@protoc_insertion_point(field_set:stream.ScanTestCfg.shape_size_max)
+}
+inline ::int32_t ScanTestCfg::_internal_shape_size_max() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.shape_size_max_;
+}
+inline void ScanTestCfg::_internal_set_shape_size_max(::int32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.shape_size_max_ = value;
+}
+
+// int32 laser_power = 5;
+inline void ScanTestCfg::clear_laser_power() {
+  _impl_.laser_power_ = 0;
+}
+inline ::int32_t ScanTestCfg::laser_power() const {
+  // @@protoc_insertion_point(field_get:stream.ScanTestCfg.laser_power)
+  return _internal_laser_power();
+}
+inline void ScanTestCfg::set_laser_power(::int32_t value) {
+  _internal_set_laser_power(value);
+  // @@protoc_insertion_point(field_set:stream.ScanTestCfg.laser_power)
+}
+inline ::int32_t ScanTestCfg::_internal_laser_power() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.laser_power_;
+}
+inline void ScanTestCfg::_internal_set_laser_power(::int32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.laser_power_ = value;
+}
+
+// int32 laser_power_min = 6;
+inline void ScanTestCfg::clear_laser_power_min() {
+  _impl_.laser_power_min_ = 0;
+}
+inline ::int32_t ScanTestCfg::laser_power_min() const {
+  // @@protoc_insertion_point(field_get:stream.ScanTestCfg.laser_power_min)
+  return _internal_laser_power_min();
+}
+inline void ScanTestCfg::set_laser_power_min(::int32_t value) {
+  _internal_set_laser_power_min(value);
+  // @@protoc_insertion_point(field_set:stream.ScanTestCfg.laser_power_min)
+}
+inline ::int32_t ScanTestCfg::_internal_laser_power_min() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.laser_power_min_;
+}
+inline void ScanTestCfg::_internal_set_laser_power_min(::int32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.laser_power_min_ = value;
+}
+
+// int32 laser_power_max = 7;
+inline void ScanTestCfg::clear_laser_power_max() {
+  _impl_.laser_power_max_ = 0;
+}
+inline ::int32_t ScanTestCfg::laser_power_max() const {
+  // @@protoc_insertion_point(field_get:stream.ScanTestCfg.laser_power_max)
+  return _internal_laser_power_max();
+}
+inline void ScanTestCfg::set_laser_power_max(::int32_t value) {
+  _internal_set_laser_power_max(value);
+  // @@protoc_insertion_point(field_set:stream.ScanTestCfg.laser_power_max)
+}
+inline ::int32_t ScanTestCfg::_internal_laser_power_max() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.laser_power_max_;
+}
+inline void ScanTestCfg::_internal_set_laser_power_max(::int32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.laser_power_max_ = value;
+}
+
+// double defocus = 8;
+inline void ScanTestCfg::clear_defocus() {
+  _impl_.defocus_ = 0;
+}
+inline double ScanTestCfg::defocus() const {
+  // @@protoc_insertion_point(field_get:stream.ScanTestCfg.defocus)
+  return _internal_defocus();
+}
+inline void ScanTestCfg::set_defocus(double value) {
+  _internal_set_defocus(value);
+  // @@protoc_insertion_point(field_set:stream.ScanTestCfg.defocus)
+}
+inline double ScanTestCfg::_internal_defocus() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.defocus_;
+}
+inline void ScanTestCfg::_internal_set_defocus(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.defocus_ = value;
+}
+
+// double defocus_min = 9;
+inline void ScanTestCfg::clear_defocus_min() {
+  _impl_.defocus_min_ = 0;
+}
+inline double ScanTestCfg::defocus_min() const {
+  // @@protoc_insertion_point(field_get:stream.ScanTestCfg.defocus_min)
+  return _internal_defocus_min();
+}
+inline void ScanTestCfg::set_defocus_min(double value) {
+  _internal_set_defocus_min(value);
+  // @@protoc_insertion_point(field_set:stream.ScanTestCfg.defocus_min)
+}
+inline double ScanTestCfg::_internal_defocus_min() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.defocus_min_;
+}
+inline void ScanTestCfg::_internal_set_defocus_min(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.defocus_min_ = value;
+}
+
+// double defocus_max = 10;
+inline void ScanTestCfg::clear_defocus_max() {
+  _impl_.defocus_max_ = 0;
+}
+inline double ScanTestCfg::defocus_max() const {
+  // @@protoc_insertion_point(field_get:stream.ScanTestCfg.defocus_max)
+  return _internal_defocus_max();
+}
+inline void ScanTestCfg::set_defocus_max(double value) {
+  _internal_set_defocus_max(value);
+  // @@protoc_insertion_point(field_set:stream.ScanTestCfg.defocus_max)
+}
+inline double ScanTestCfg::_internal_defocus_max() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.defocus_max_;
+}
+inline void ScanTestCfg::_internal_set_defocus_max(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.defocus_max_ = value;
+}
+
+// bool is_cycle = 11;
+inline void ScanTestCfg::clear_is_cycle() {
+  _impl_.is_cycle_ = false;
+}
+inline bool ScanTestCfg::is_cycle() const {
+  // @@protoc_insertion_point(field_get:stream.ScanTestCfg.is_cycle)
+  return _internal_is_cycle();
+}
+inline void ScanTestCfg::set_is_cycle(bool value) {
+  _internal_set_is_cycle(value);
+  // @@protoc_insertion_point(field_set:stream.ScanTestCfg.is_cycle)
+}
+inline bool ScanTestCfg::_internal_is_cycle() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.is_cycle_;
+}
+inline void ScanTestCfg::_internal_set_is_cycle(bool value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.is_cycle_ = value;
+}
+
+// double cross_x = 12;
+inline void ScanTestCfg::clear_cross_x() {
+  _impl_.cross_x_ = 0;
+}
+inline double ScanTestCfg::cross_x() const {
+  // @@protoc_insertion_point(field_get:stream.ScanTestCfg.cross_x)
+  return _internal_cross_x();
+}
+inline void ScanTestCfg::set_cross_x(double value) {
+  _internal_set_cross_x(value);
+  // @@protoc_insertion_point(field_set:stream.ScanTestCfg.cross_x)
+}
+inline double ScanTestCfg::_internal_cross_x() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.cross_x_;
+}
+inline void ScanTestCfg::_internal_set_cross_x(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.cross_x_ = value;
+}
+
+// double cross_y = 13;
+inline void ScanTestCfg::clear_cross_y() {
+  _impl_.cross_y_ = 0;
+}
+inline double ScanTestCfg::cross_y() const {
+  // @@protoc_insertion_point(field_get:stream.ScanTestCfg.cross_y)
+  return _internal_cross_y();
+}
+inline void ScanTestCfg::set_cross_y(double value) {
+  _internal_set_cross_y(value);
+  // @@protoc_insertion_point(field_set:stream.ScanTestCfg.cross_y)
+}
+inline double ScanTestCfg::_internal_cross_y() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.cross_y_;
+}
+inline void ScanTestCfg::_internal_set_cross_y(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.cross_y_ = value;
+}
+
+// double z_distance = 14;
+inline void ScanTestCfg::clear_z_distance() {
+  _impl_.z_distance_ = 0;
+}
+inline double ScanTestCfg::z_distance() const {
+  // @@protoc_insertion_point(field_get:stream.ScanTestCfg.z_distance)
+  return _internal_z_distance();
+}
+inline void ScanTestCfg::set_z_distance(double value) {
+  _internal_set_z_distance(value);
+  // @@protoc_insertion_point(field_set:stream.ScanTestCfg.z_distance)
+}
+inline double ScanTestCfg::_internal_z_distance() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.z_distance_;
+}
+inline void ScanTestCfg::_internal_set_z_distance(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.z_distance_ = value;
+}
+
+// bool isAutoHeatingScanner = 15;
+inline void ScanTestCfg::clear_isautoheatingscanner() {
+  _impl_.isautoheatingscanner_ = false;
+}
+inline bool ScanTestCfg::isautoheatingscanner() const {
+  // @@protoc_insertion_point(field_get:stream.ScanTestCfg.isAutoHeatingScanner)
+  return _internal_isautoheatingscanner();
+}
+inline void ScanTestCfg::set_isautoheatingscanner(bool value) {
+  _internal_set_isautoheatingscanner(value);
+  // @@protoc_insertion_point(field_set:stream.ScanTestCfg.isAutoHeatingScanner)
+}
+inline bool ScanTestCfg::_internal_isautoheatingscanner() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.isautoheatingscanner_;
+}
+inline void ScanTestCfg::_internal_set_isautoheatingscanner(bool value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.isautoheatingscanner_ = value;
+}
+
+// uint32 autoHeatingScannerMinutes = 16;
+inline void ScanTestCfg::clear_autoheatingscannerminutes() {
+  _impl_.autoheatingscannerminutes_ = 0u;
+}
+inline ::uint32_t ScanTestCfg::autoheatingscannerminutes() const {
+  // @@protoc_insertion_point(field_get:stream.ScanTestCfg.autoHeatingScannerMinutes)
+  return _internal_autoheatingscannerminutes();
+}
+inline void ScanTestCfg::set_autoheatingscannerminutes(::uint32_t value) {
+  _internal_set_autoheatingscannerminutes(value);
+  // @@protoc_insertion_point(field_set:stream.ScanTestCfg.autoHeatingScannerMinutes)
+}
+inline ::uint32_t ScanTestCfg::_internal_autoheatingscannerminutes() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.autoheatingscannerminutes_;
+}
+inline void ScanTestCfg::_internal_set_autoheatingscannerminutes(::uint32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.autoheatingscannerminutes_ = value;
+}
+
+// uint32 autoHeatingScannerSize = 17;
+inline void ScanTestCfg::clear_autoheatingscannersize() {
+  _impl_.autoheatingscannersize_ = 0u;
+}
+inline ::uint32_t ScanTestCfg::autoheatingscannersize() const {
+  // @@protoc_insertion_point(field_get:stream.ScanTestCfg.autoHeatingScannerSize)
+  return _internal_autoheatingscannersize();
+}
+inline void ScanTestCfg::set_autoheatingscannersize(::uint32_t value) {
+  _internal_set_autoheatingscannersize(value);
+  // @@protoc_insertion_point(field_set:stream.ScanTestCfg.autoHeatingScannerSize)
+}
+inline ::uint32_t ScanTestCfg::_internal_autoheatingscannersize() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.autoheatingscannersize_;
+}
+inline void ScanTestCfg::_internal_set_autoheatingscannersize(::uint32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.autoheatingscannersize_ = value;
+}
+
+// double autoHeatingScannerSpeed = 18;
+inline void ScanTestCfg::clear_autoheatingscannerspeed() {
+  _impl_.autoheatingscannerspeed_ = 0;
+}
+inline double ScanTestCfg::autoheatingscannerspeed() const {
+  // @@protoc_insertion_point(field_get:stream.ScanTestCfg.autoHeatingScannerSpeed)
+  return _internal_autoheatingscannerspeed();
+}
+inline void ScanTestCfg::set_autoheatingscannerspeed(double value) {
+  _internal_set_autoheatingscannerspeed(value);
+  // @@protoc_insertion_point(field_set:stream.ScanTestCfg.autoHeatingScannerSpeed)
+}
+inline double ScanTestCfg::_internal_autoheatingscannerspeed() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.autoheatingscannerspeed_;
+}
+inline void ScanTestCfg::_internal_set_autoheatingscannerspeed(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.autoheatingscannerspeed_ = value;
+}
+
+// double mark_test_start_x = 19;
+inline void ScanTestCfg::clear_mark_test_start_x() {
+  _impl_.mark_test_start_x_ = 0;
+}
+inline double ScanTestCfg::mark_test_start_x() const {
+  // @@protoc_insertion_point(field_get:stream.ScanTestCfg.mark_test_start_x)
+  return _internal_mark_test_start_x();
+}
+inline void ScanTestCfg::set_mark_test_start_x(double value) {
+  _internal_set_mark_test_start_x(value);
+  // @@protoc_insertion_point(field_set:stream.ScanTestCfg.mark_test_start_x)
+}
+inline double ScanTestCfg::_internal_mark_test_start_x() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.mark_test_start_x_;
+}
+inline void ScanTestCfg::_internal_set_mark_test_start_x(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.mark_test_start_x_ = value;
+}
+
+// double mark_test_start_y = 20;
+inline void ScanTestCfg::clear_mark_test_start_y() {
+  _impl_.mark_test_start_y_ = 0;
+}
+inline double ScanTestCfg::mark_test_start_y() const {
+  // @@protoc_insertion_point(field_get:stream.ScanTestCfg.mark_test_start_y)
+  return _internal_mark_test_start_y();
+}
+inline void ScanTestCfg::set_mark_test_start_y(double value) {
+  _internal_set_mark_test_start_y(value);
+  // @@protoc_insertion_point(field_set:stream.ScanTestCfg.mark_test_start_y)
+}
+inline double ScanTestCfg::_internal_mark_test_start_y() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.mark_test_start_y_;
+}
+inline void ScanTestCfg::_internal_set_mark_test_start_y(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.mark_test_start_y_ = value;
+}
+
+// double mark_test_end_x = 21;
+inline void ScanTestCfg::clear_mark_test_end_x() {
+  _impl_.mark_test_end_x_ = 0;
+}
+inline double ScanTestCfg::mark_test_end_x() const {
+  // @@protoc_insertion_point(field_get:stream.ScanTestCfg.mark_test_end_x)
+  return _internal_mark_test_end_x();
+}
+inline void ScanTestCfg::set_mark_test_end_x(double value) {
+  _internal_set_mark_test_end_x(value);
+  // @@protoc_insertion_point(field_set:stream.ScanTestCfg.mark_test_end_x)
+}
+inline double ScanTestCfg::_internal_mark_test_end_x() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.mark_test_end_x_;
+}
+inline void ScanTestCfg::_internal_set_mark_test_end_x(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.mark_test_end_x_ = value;
+}
+
+// double mark_test_end_y = 22;
+inline void ScanTestCfg::clear_mark_test_end_y() {
+  _impl_.mark_test_end_y_ = 0;
+}
+inline double ScanTestCfg::mark_test_end_y() const {
+  // @@protoc_insertion_point(field_get:stream.ScanTestCfg.mark_test_end_y)
+  return _internal_mark_test_end_y();
+}
+inline void ScanTestCfg::set_mark_test_end_y(double value) {
+  _internal_set_mark_test_end_y(value);
+  // @@protoc_insertion_point(field_set:stream.ScanTestCfg.mark_test_end_y)
+}
+inline double ScanTestCfg::_internal_mark_test_end_y() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.mark_test_end_y_;
+}
+inline void ScanTestCfg::_internal_set_mark_test_end_y(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.mark_test_end_y_ = value;
+}
+
+// -------------------------------------------------------------------
+
+// SkyWritingCfg
+
+// bool isEnable = 1;
+inline void SkyWritingCfg::clear_isenable() {
+  _impl_.isenable_ = false;
+}
+inline bool SkyWritingCfg::isenable() const {
+  // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.isEnable)
+  return _internal_isenable();
+}
+inline void SkyWritingCfg::set_isenable(bool value) {
+  _internal_set_isenable(value);
+  // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.isEnable)
+}
+inline bool SkyWritingCfg::_internal_isenable() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.isenable_;
+}
+inline void SkyWritingCfg::_internal_set_isenable(bool value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.isenable_ = value;
+}
+
+// double timelag = 2;
+inline void SkyWritingCfg::clear_timelag() {
+  _impl_.timelag_ = 0;
+}
+inline double SkyWritingCfg::timelag() const {
+  // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.timelag)
+  return _internal_timelag();
+}
+inline void SkyWritingCfg::set_timelag(double value) {
+  _internal_set_timelag(value);
+  // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.timelag)
+}
+inline double SkyWritingCfg::_internal_timelag() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.timelag_;
+}
+inline void SkyWritingCfg::_internal_set_timelag(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.timelag_ = value;
+}
+
+// double timelagMin = 3;
+inline void SkyWritingCfg::clear_timelagmin() {
+  _impl_.timelagmin_ = 0;
+}
+inline double SkyWritingCfg::timelagmin() const {
+  // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.timelagMin)
+  return _internal_timelagmin();
+}
+inline void SkyWritingCfg::set_timelagmin(double value) {
+  _internal_set_timelagmin(value);
+  // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.timelagMin)
+}
+inline double SkyWritingCfg::_internal_timelagmin() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.timelagmin_;
+}
+inline void SkyWritingCfg::_internal_set_timelagmin(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.timelagmin_ = value;
+}
+
+// double timelagMax = 4;
+inline void SkyWritingCfg::clear_timelagmax() {
+  _impl_.timelagmax_ = 0;
+}
+inline double SkyWritingCfg::timelagmax() const {
+  // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.timelagMax)
+  return _internal_timelagmax();
+}
+inline void SkyWritingCfg::set_timelagmax(double value) {
+  _internal_set_timelagmax(value);
+  // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.timelagMax)
+}
+inline double SkyWritingCfg::_internal_timelagmax() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.timelagmax_;
+}
+inline void SkyWritingCfg::_internal_set_timelagmax(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.timelagmax_ = value;
+}
+
+// int64 laserOnShift = 5;
+inline void SkyWritingCfg::clear_laseronshift() {
+  _impl_.laseronshift_ = ::int64_t{0};
+}
+inline ::int64_t SkyWritingCfg::laseronshift() const {
+  // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.laserOnShift)
+  return _internal_laseronshift();
+}
+inline void SkyWritingCfg::set_laseronshift(::int64_t value) {
+  _internal_set_laseronshift(value);
+  // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.laserOnShift)
+}
+inline ::int64_t SkyWritingCfg::_internal_laseronshift() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.laseronshift_;
+}
+inline void SkyWritingCfg::_internal_set_laseronshift(::int64_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.laseronshift_ = value;
+}
+
+// int64 laserOnShiftMin = 6;
+inline void SkyWritingCfg::clear_laseronshiftmin() {
+  _impl_.laseronshiftmin_ = ::int64_t{0};
+}
+inline ::int64_t SkyWritingCfg::laseronshiftmin() const {
+  // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.laserOnShiftMin)
+  return _internal_laseronshiftmin();
+}
+inline void SkyWritingCfg::set_laseronshiftmin(::int64_t value) {
+  _internal_set_laseronshiftmin(value);
+  // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.laserOnShiftMin)
+}
+inline ::int64_t SkyWritingCfg::_internal_laseronshiftmin() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.laseronshiftmin_;
+}
+inline void SkyWritingCfg::_internal_set_laseronshiftmin(::int64_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.laseronshiftmin_ = value;
+}
+
+// int64 laserOnShiftMax = 7;
+inline void SkyWritingCfg::clear_laseronshiftmax() {
+  _impl_.laseronshiftmax_ = ::int64_t{0};
+}
+inline ::int64_t SkyWritingCfg::laseronshiftmax() const {
+  // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.laserOnShiftMax)
+  return _internal_laseronshiftmax();
+}
+inline void SkyWritingCfg::set_laseronshiftmax(::int64_t value) {
+  _internal_set_laseronshiftmax(value);
+  // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.laserOnShiftMax)
+}
+inline ::int64_t SkyWritingCfg::_internal_laseronshiftmax() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.laseronshiftmax_;
+}
+inline void SkyWritingCfg::_internal_set_laseronshiftmax(::int64_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.laseronshiftmax_ = value;
+}
+
+// uint32 nprev = 8;
+inline void SkyWritingCfg::clear_nprev() {
+  _impl_.nprev_ = 0u;
+}
+inline ::uint32_t SkyWritingCfg::nprev() const {
+  // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.nprev)
+  return _internal_nprev();
+}
+inline void SkyWritingCfg::set_nprev(::uint32_t value) {
+  _internal_set_nprev(value);
+  // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.nprev)
+}
+inline ::uint32_t SkyWritingCfg::_internal_nprev() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.nprev_;
+}
+inline void SkyWritingCfg::_internal_set_nprev(::uint32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.nprev_ = value;
+}
+
+// uint32 nprevMin = 9;
+inline void SkyWritingCfg::clear_nprevmin() {
+  _impl_.nprevmin_ = 0u;
+}
+inline ::uint32_t SkyWritingCfg::nprevmin() const {
+  // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.nprevMin)
+  return _internal_nprevmin();
+}
+inline void SkyWritingCfg::set_nprevmin(::uint32_t value) {
+  _internal_set_nprevmin(value);
+  // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.nprevMin)
+}
+inline ::uint32_t SkyWritingCfg::_internal_nprevmin() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.nprevmin_;
+}
+inline void SkyWritingCfg::_internal_set_nprevmin(::uint32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.nprevmin_ = value;
+}
+
+// uint32 nprevMax = 10;
+inline void SkyWritingCfg::clear_nprevmax() {
+  _impl_.nprevmax_ = 0u;
+}
+inline ::uint32_t SkyWritingCfg::nprevmax() const {
+  // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.nprevMax)
+  return _internal_nprevmax();
+}
+inline void SkyWritingCfg::set_nprevmax(::uint32_t value) {
+  _internal_set_nprevmax(value);
+  // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.nprevMax)
+}
+inline ::uint32_t SkyWritingCfg::_internal_nprevmax() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.nprevmax_;
+}
+inline void SkyWritingCfg::_internal_set_nprevmax(::uint32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.nprevmax_ = value;
+}
+
+// uint32 npost = 11;
+inline void SkyWritingCfg::clear_npost() {
+  _impl_.npost_ = 0u;
+}
+inline ::uint32_t SkyWritingCfg::npost() const {
+  // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.npost)
+  return _internal_npost();
+}
+inline void SkyWritingCfg::set_npost(::uint32_t value) {
+  _internal_set_npost(value);
+  // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.npost)
+}
+inline ::uint32_t SkyWritingCfg::_internal_npost() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.npost_;
+}
+inline void SkyWritingCfg::_internal_set_npost(::uint32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.npost_ = value;
+}
+
+// uint32 npostMin = 12;
+inline void SkyWritingCfg::clear_npostmin() {
+  _impl_.npostmin_ = 0u;
+}
+inline ::uint32_t SkyWritingCfg::npostmin() const {
+  // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.npostMin)
+  return _internal_npostmin();
+}
+inline void SkyWritingCfg::set_npostmin(::uint32_t value) {
+  _internal_set_npostmin(value);
+  // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.npostMin)
+}
+inline ::uint32_t SkyWritingCfg::_internal_npostmin() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.npostmin_;
+}
+inline void SkyWritingCfg::_internal_set_npostmin(::uint32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.npostmin_ = value;
+}
+
+// uint32 npostMax = 13;
+inline void SkyWritingCfg::clear_npostmax() {
+  _impl_.npostmax_ = 0u;
+}
+inline ::uint32_t SkyWritingCfg::npostmax() const {
+  // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.npostMax)
+  return _internal_npostmax();
+}
+inline void SkyWritingCfg::set_npostmax(::uint32_t value) {
+  _internal_set_npostmax(value);
+  // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.npostMax)
+}
+inline ::uint32_t SkyWritingCfg::_internal_npostmax() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.npostmax_;
+}
+inline void SkyWritingCfg::_internal_set_npostmax(::uint32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.npostmax_ = value;
+}
+
+// int32 mode = 14;
+inline void SkyWritingCfg::clear_mode() {
+  _impl_.mode_ = 0;
+}
+inline ::int32_t SkyWritingCfg::mode() const {
+  // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.mode)
+  return _internal_mode();
+}
+inline void SkyWritingCfg::set_mode(::int32_t value) {
+  _internal_set_mode(value);
+  // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.mode)
+}
+inline ::int32_t SkyWritingCfg::_internal_mode() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.mode_;
+}
+inline void SkyWritingCfg::_internal_set_mode(::int32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.mode_ = value;
+}
+
+// double limite = 15;
+inline void SkyWritingCfg::clear_limite() {
+  _impl_.limite_ = 0;
+}
+inline double SkyWritingCfg::limite() const {
+  // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.limite)
+  return _internal_limite();
+}
+inline void SkyWritingCfg::set_limite(double value) {
+  _internal_set_limite(value);
+  // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.limite)
+}
+inline double SkyWritingCfg::_internal_limite() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.limite_;
+}
+inline void SkyWritingCfg::_internal_set_limite(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.limite_ = value;
+}
+
+// double limiteMin = 16;
+inline void SkyWritingCfg::clear_limitemin() {
+  _impl_.limitemin_ = 0;
+}
+inline double SkyWritingCfg::limitemin() const {
+  // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.limiteMin)
+  return _internal_limitemin();
+}
+inline void SkyWritingCfg::set_limitemin(double value) {
+  _internal_set_limitemin(value);
+  // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.limiteMin)
+}
+inline double SkyWritingCfg::_internal_limitemin() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.limitemin_;
+}
+inline void SkyWritingCfg::_internal_set_limitemin(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.limitemin_ = value;
+}
+
+// double limiteMax = 17;
+inline void SkyWritingCfg::clear_limitemax() {
+  _impl_.limitemax_ = 0;
+}
+inline double SkyWritingCfg::limitemax() const {
+  // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.limiteMax)
+  return _internal_limitemax();
+}
+inline void SkyWritingCfg::set_limitemax(double value) {
+  _internal_set_limitemax(value);
+  // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.limiteMax)
+}
+inline double SkyWritingCfg::_internal_limitemax() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.limitemax_;
+}
+inline void SkyWritingCfg::_internal_set_limitemax(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.limitemax_ = value;
+}
+
+// -------------------------------------------------------------------
+
+// PowerCompensate
+
+// int32 cno = 1;
+inline void PowerCompensate::clear_cno() {
+  _impl_.cno_ = 0;
+}
+inline ::int32_t PowerCompensate::cno() const {
+  // @@protoc_insertion_point(field_get:stream.PowerCompensate.cno)
+  return _internal_cno();
+}
+inline void PowerCompensate::set_cno(::int32_t value) {
+  _internal_set_cno(value);
+  // @@protoc_insertion_point(field_set:stream.PowerCompensate.cno)
+}
+inline ::int32_t PowerCompensate::_internal_cno() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.cno_;
+}
+inline void PowerCompensate::_internal_set_cno(::int32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.cno_ = value;
+}
+
+// int32 percent = 2;
+inline void PowerCompensate::clear_percent() {
+  _impl_.percent_ = 0;
+}
+inline ::int32_t PowerCompensate::percent() const {
+  // @@protoc_insertion_point(field_get:stream.PowerCompensate.percent)
+  return _internal_percent();
+}
+inline void PowerCompensate::set_percent(::int32_t value) {
+  _internal_set_percent(value);
+  // @@protoc_insertion_point(field_set:stream.PowerCompensate.percent)
+}
+inline ::int32_t PowerCompensate::_internal_percent() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.percent_;
+}
+inline void PowerCompensate::_internal_set_percent(::int32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.percent_ = value;
+}
+
+// float value = 3;
+inline void PowerCompensate::clear_value() {
+  _impl_.value_ = 0;
+}
+inline float PowerCompensate::value() const {
+  // @@protoc_insertion_point(field_get:stream.PowerCompensate.value)
+  return _internal_value();
+}
+inline void PowerCompensate::set_value(float value) {
+  _internal_set_value(value);
+  // @@protoc_insertion_point(field_set:stream.PowerCompensate.value)
+}
+inline float PowerCompensate::_internal_value() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.value_;
+}
+inline void PowerCompensate::_internal_set_value(float value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.value_ = value;
+}
+
+// float value_min = 4;
+inline void PowerCompensate::clear_value_min() {
+  _impl_.value_min_ = 0;
+}
+inline float PowerCompensate::value_min() const {
+  // @@protoc_insertion_point(field_get:stream.PowerCompensate.value_min)
+  return _internal_value_min();
+}
+inline void PowerCompensate::set_value_min(float value) {
+  _internal_set_value_min(value);
+  // @@protoc_insertion_point(field_set:stream.PowerCompensate.value_min)
+}
+inline float PowerCompensate::_internal_value_min() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.value_min_;
+}
+inline void PowerCompensate::_internal_set_value_min(float value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.value_min_ = value;
+}
+
+// float value_max = 5;
+inline void PowerCompensate::clear_value_max() {
+  _impl_.value_max_ = 0;
+}
+inline float PowerCompensate::value_max() const {
+  // @@protoc_insertion_point(field_get:stream.PowerCompensate.value_max)
+  return _internal_value_max();
+}
+inline void PowerCompensate::set_value_max(float value) {
+  _internal_set_value_max(value);
+  // @@protoc_insertion_point(field_set:stream.PowerCompensate.value_max)
+}
+inline float PowerCompensate::_internal_value_max() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.value_max_;
+}
+inline void PowerCompensate::_internal_set_value_max(float value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.value_max_ = value;
+}
+
+// -------------------------------------------------------------------
+
+// TimePowerCompensate
+
+// int32 id = 1;
+inline void TimePowerCompensate::clear_id() {
+  _impl_.id_ = 0;
+}
+inline ::int32_t TimePowerCompensate::id() const {
+  // @@protoc_insertion_point(field_get:stream.TimePowerCompensate.id)
+  return _internal_id();
+}
+inline void TimePowerCompensate::set_id(::int32_t value) {
+  _internal_set_id(value);
+  // @@protoc_insertion_point(field_set:stream.TimePowerCompensate.id)
+}
+inline ::int32_t TimePowerCompensate::_internal_id() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.id_;
+}
+inline void TimePowerCompensate::_internal_set_id(::int32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.id_ = value;
+}
+
+// int32 cno = 2;
+inline void TimePowerCompensate::clear_cno() {
+  _impl_.cno_ = 0;
+}
+inline ::int32_t TimePowerCompensate::cno() const {
+  // @@protoc_insertion_point(field_get:stream.TimePowerCompensate.cno)
+  return _internal_cno();
+}
+inline void TimePowerCompensate::set_cno(::int32_t value) {
+  _internal_set_cno(value);
+  // @@protoc_insertion_point(field_set:stream.TimePowerCompensate.cno)
+}
+inline ::int32_t TimePowerCompensate::_internal_cno() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.cno_;
+}
+inline void TimePowerCompensate::_internal_set_cno(::int32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.cno_ = value;
+}
+
+// uint32 startMinute = 3;
+inline void TimePowerCompensate::clear_startminute() {
+  _impl_.startminute_ = 0u;
+}
+inline ::uint32_t TimePowerCompensate::startminute() const {
+  // @@protoc_insertion_point(field_get:stream.TimePowerCompensate.startMinute)
+  return _internal_startminute();
+}
+inline void TimePowerCompensate::set_startminute(::uint32_t value) {
+  _internal_set_startminute(value);
+  // @@protoc_insertion_point(field_set:stream.TimePowerCompensate.startMinute)
+}
+inline ::uint32_t TimePowerCompensate::_internal_startminute() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.startminute_;
+}
+inline void TimePowerCompensate::_internal_set_startminute(::uint32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.startminute_ = value;
+}
+
+// uint32 endMinute = 4;
+inline void TimePowerCompensate::clear_endminute() {
+  _impl_.endminute_ = 0u;
+}
+inline ::uint32_t TimePowerCompensate::endminute() const {
+  // @@protoc_insertion_point(field_get:stream.TimePowerCompensate.endMinute)
+  return _internal_endminute();
+}
+inline void TimePowerCompensate::set_endminute(::uint32_t value) {
+  _internal_set_endminute(value);
+  // @@protoc_insertion_point(field_set:stream.TimePowerCompensate.endMinute)
+}
+inline ::uint32_t TimePowerCompensate::_internal_endminute() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.endminute_;
+}
+inline void TimePowerCompensate::_internal_set_endminute(::uint32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.endminute_ = value;
+}
+
+// float compensate = 5;
+inline void TimePowerCompensate::clear_compensate() {
+  _impl_.compensate_ = 0;
+}
+inline float TimePowerCompensate::compensate() const {
+  // @@protoc_insertion_point(field_get:stream.TimePowerCompensate.compensate)
+  return _internal_compensate();
+}
+inline void TimePowerCompensate::set_compensate(float value) {
+  _internal_set_compensate(value);
+  // @@protoc_insertion_point(field_set:stream.TimePowerCompensate.compensate)
+}
+inline float TimePowerCompensate::_internal_compensate() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.compensate_;
+}
+inline void TimePowerCompensate::_internal_set_compensate(float value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.compensate_ = value;
+}
+
 #ifdef __GNUC__
 #pragma GCC diagnostic pop
 #endif  // __GNUC__
diff --git a/PrintS/protobuf/stream.proto b/PrintS/protobuf/stream.proto
index bd2e304..d5ff934 100644
--- a/PrintS/protobuf/stream.proto
+++ b/PrintS/protobuf/stream.proto
@@ -48,6 +48,15 @@ message ParamInfo{
 	int32 startLayer = 8;   //层供粉量配置使用  struct PowderSet
     int32 endLayer = 9;
     float powder = 10;
+
+	int32 seqNo = 11;   //ScannerControlCfg使用
+    int32 controlNo = 12;
+    int32 serialNo = 13;
+    int32 controlType = 14;
+    bytes cardName = 15;
+    bytes cardIP = 16;
+    bool hadAssign = 17;
+    bool hadMatch = 18;   //isEnable公用
 }
 
 message RequestInfo {   //读
@@ -135,9 +144,174 @@ message ComResponce{
 	bytes  data = 1;
 }
 
+//ScannerCrtlCfg结构体
+message ScannerCrtlCfgResp{
+	repeated ScannerCrtlCfgData scannerCfg = 1;
+}
+
+message ScannerCrtlCfgData{
+	int32 seqNo = 1;
+
+	repeated FixPointData fixPointData = 2;
+	ScanParamCfg scanParamCfg = 3;
+	ScanParamCfg  hatchingParams = 4;
+	ScanParamCfg  borderParams = 5;
+	ScanParamCfg  supportParams = 6;
+	CorrectParamCfg  correctParamCfg = 7;
+	ScanTestCfg  scanTestCfg = 8;
+	SkyWritingCfg skyWritingCfg = 9;
+	repeated PowerCompensate powerCompensate = 10;
+	repeated TimePowerCompensate tPowerCompensate = 11;
+
+	int32 controlNo = 12;
+	int32 serialNo = 13;
+	int32 controlType = 14;
+	bytes cardName = 15;
+	bytes cardIP = 16;
+	bool isEnable = 17;				//是否启动
+	bool hadAssign = 18;
+	bool hadMatch = 19;
+}
+
+message FixPointData{
+	int32 id = 1;
+	int32 cno = 2;
+	float pointX = 3;
+	float pointY = 4;
+	uint32 duration = 5;
+}
+
+
+
+message ScanParamCfg{
+	int32 edgeLevel = 1;
+	int32 edgeLevelMin = 2;
+	int32 edgeLevelMax = 3;
+	uint32 jumpDelay = 4;
+	uint32 jumpDelayMin = 5;
+	uint32 jumpDelayMax = 6;
+	uint32 scanDelay = 7;
+	uint32 scanDelayMin = 8;
+	uint32 scanDelayMax = 9;
+	uint32 polygonDelay = 10;
+	uint32 polygonDelayMin = 11;
+	uint32 polygonDelayMax = 12;
+	int64 laseroffDelay = 13;
+	int64 laseroffDelayMin = 14;
+	int64 laseroffDelayMax = 15;
+	int64 laseronDelay = 16;
+	int64 laseronDelayMin = 17;
+	int64 laseronDelayMax = 18;
+	uint32 minJumpDelay = 19;
+	uint32 minJumpDelayMin = 20;
+	uint32  minJumpDelayMax = 21;
+	uint32  jumpLengthLimit = 22;
+	uint32  jumpLengthLimitMin = 23;
+	uint32  jumpLengthLimitMax = 24;
+	double  jumpSpeed = 25;
+	double  jumpSpeedMin = 26;
+	double  jumpSpeedMax = 27;
+	double  markSpeed = 28;
+	double  markSpeedMin = 29;
+	double  markSpeedMax = 30;
+}
+
+message CorrectParamCfg{
+	double xmeasureMin = 1;			//x可打印最小位置
+	double xmeasureMax = 2;			//x可打印最大位置
+	double ymeasureMin = 3;			//y可打印最小位置
+	double ymeasureMax = 4;			//y可打印最大位置
+	double xposfix = 5;				//x位置修正
+	double yposfix = 6;				//y位置修正
+	double scanAngle = 7;					//旋转角度  逆时针
+	double scanAngleMin = 8;
+	double scanAngleMax = 9;
+	double fixAngle = 10;					//旋转角度  逆时针
+	double fixAngleMin = 11;
+	double fixAngleMax = 12;
+	double xcorrect = 13;				//x尺寸修正
+	double ycorrect = 14;				//y尺寸修正
+	double xcorrectMin = 15;
+	double xcorrectMax = 16;
+	double ycorrectMin = 17;
+	double ycorrectMax = 18;
+	double realXOffset = 19;
+	double realYOffset = 20;
+	double factorK = 21;
+	bool isCorrectFile3D = 22;
+	bool isDynamicFocus = 23;		//是否动态聚焦
+	double defocusRatio = 24;		//离焦比
+	double defocusRatioMin = 25;
+	double defocusRatioMax = 26;
+}
+
+message ScanTestCfg{
+	int32 debugShape = 1;
+	int32 shapeSize = 2;
+	int32 shapeSizeMin = 3;
+	int32  shape_size_max = 4;
+	int32  laser_power = 5;
+	int32  laser_power_min = 6;
+	int32  laser_power_max = 7;
+	double  defocus = 8;
+	double  defocus_min = 9;
+	double  defocus_max = 10;
+	bool    is_cycle = 11;
+	double  cross_x = 12;
+	double  cross_y = 13;
+	double  z_distance = 14;
+	bool  isAutoHeatingScanner = 15;		//开启暂停开始时预热振镜
+	uint32  autoHeatingScannerMinutes = 16;
+	uint32  autoHeatingScannerSize = 17;
+	double  autoHeatingScannerSpeed = 18;
+	double  mark_test_start_x = 19;
+	double  mark_test_start_y = 20;
+	double  mark_test_end_x = 21;
+	double  mark_test_end_y = 22;
+}
+
+message SkyWritingCfg{
+	bool isEnable = 1;
+	double timelag = 2;
+	double timelagMin = 3;
+	double timelagMax = 4;
+	int64 laserOnShift = 5;
+	int64 laserOnShiftMin = 6;
+	int64 laserOnShiftMax = 7;
+	uint32  nprev = 8;
+	uint32 nprevMin =9;
+	uint32 nprevMax = 10;
+	uint32 npost = 11;
+	uint32 npostMin = 12;
+	uint32 npostMax = 13;
+	int32 mode = 14;
+	double limite = 15;
+	double limiteMin = 16;
+	double limiteMax = 17;
+}
+
+
+message PowerCompensate{
+	int32 cno = 1;
+	int32 percent = 2;
+	float value = 3;
+	float value_min = 4;
+	float value_max = 5;
+}
+
+message TimePowerCompensate{
+	int32 id = 1;
+	int32 cno = 2;
+	uint32 startMinute = 3;
+	uint32 endMinute = 4;
+	float compensate = 5;
+}
+
 service Stream {
   rpc Simple(RequestInfo) returns (ResponseAny) {} // 简单模式
   rpc ServerStream (RequestInfo) returns (stream ResponseInfo) {} // 服务端数据流模式
   rpc ClientStream (stream RequestInfo) returns (ResponseInfo) {} // 客户端数据流模式
   rpc AllStream (stream RequestInfo) returns (stream ResponseInfo) {} // 双向数据流模式
 }
+
+
diff --git a/TestClient/DataManage/DataHandle.cpp b/TestClient/DataManage/DataHandle.cpp
index f237791..ba4cd32 100644
--- a/TestClient/DataManage/DataHandle.cpp
+++ b/TestClient/DataManage/DataHandle.cpp
@@ -90,6 +90,11 @@ void DataHandle::PrintValue(const ReadData& msg){
 				printf("接收:dataType:%d,startLayer:%d,endLayer:%d,powder:%.2f\n",
 					msg.dataType,it->start_layer, it->end_layer, it->powder);
 			}
+			//else if (msg.dataType == SCANNERCONTROLCFGPARAM) {
+			//	printf("接收:dataType:%d,seqNo:%d,controlNo:%d,serialNo:%d,controlType:%d,cardName:%s,cardIP:%s,isEnable:%d,hadAssign:%d,hadMatch:%d\n",
+			//		msg.dataType, it->seqNo, it->controlNo, it->serialNo, it->controlType,
+			//		it->cardName.data(), it->cardIP.data(),it->isEnable, it->hadAssign,it->hadMatch);
+			//}
 			else {
 				printf("接收:dataType:%d,nameKey:%*s, strvalue:%*s, valueType:%s\n",
 					msg.dataType, 33, it->nameKey.data(), 13, it->strValue.data(), valueType.data());
@@ -185,18 +190,21 @@ void DataHandle::ParamReadUsage() {
 	printf(" 37:  " COLOR_YELLOW "print pausealarm cfg param data...\n" COLOR_RESET); 
 	printf(" 38:  " COLOR_YELLOW "print warnalarm cfg param data...\n" COLOR_RESET); 
 	printf(" 39:  " COLOR_YELLOW "print powder cfg param data...\n" COLOR_RESET); 
+	printf(" 40:  " COLOR_YELLOW "print powder cfg param data...\n" COLOR_RESET); 
+	printf(" 41:  " COLOR_YELLOW "print scaner ctrl cfg param data...\n" COLOR_RESET); 
 	
-	printf(" 40:  " COLOR_YELLOW "print moldcfg param data...\n" COLOR_RESET);
-	printf(" 41:  " COLOR_YELLOW "print loadcfg param data...\n" COLOR_RESET);
-	printf(" 42:  " COLOR_YELLOW "print armcfgparam data...\n" COLOR_RESET);
-	printf(" 43:  " COLOR_YELLOW "print supplycfgparam data...\n" COLOR_RESET);
-	printf(" 44:  " COLOR_YELLOW "print cleancfgparam data...\n" COLOR_RESET);
-	printf(" 45:  " COLOR_YELLOW "print elecfgparam data...\n" COLOR_RESET);
-	printf(" 46:  " COLOR_YELLOW "print loadparamrsp data...\n" COLOR_RESET);
-	printf(" 47:  " COLOR_YELLOW "print scan ctrl state data...\n" COLOR_RESET);
-	printf(" 48:  " COLOR_YELLOW "print scan ctrl Param data...\n" COLOR_RESET);
-	printf(" 49:  " COLOR_YELLOW "print xy scan state data...\n" COLOR_RESET);
-	printf(" 50:  " COLOR_YELLOW "print camera param data...\n" COLOR_RESET);
+	printf(" 42:  " COLOR_YELLOW "print moldcfg param data...\n" COLOR_RESET);
+	printf(" 43:  " COLOR_YELLOW "print loadcfg param data...\n" COLOR_RESET);
+	printf(" 44:  " COLOR_YELLOW "print armcfgparam data...\n" COLOR_RESET);
+	printf(" 45:  " COLOR_YELLOW "print supplycfgparam data...\n" COLOR_RESET);
+	printf(" 46:  " COLOR_YELLOW "print cleancfgparam data...\n" COLOR_RESET);
+	printf(" 47:  " COLOR_YELLOW "print elecfgparam data...\n" COLOR_RESET);
+	printf(" 48:  " COLOR_YELLOW "print loadparamrsp data...\n" COLOR_RESET);
+	printf(" 49:  " COLOR_YELLOW "print scan ctrl state data...\n" COLOR_RESET);
+	printf(" 50:  " COLOR_YELLOW "print scan ctrl Param data...\n" COLOR_RESET);
+	printf(" 51:  " COLOR_YELLOW "print xy scan state data...\n" COLOR_RESET);
+	printf(" 52:  " COLOR_YELLOW "print camera param data...\n" COLOR_RESET);
+
 }
 
 int DataHandle::Request(int index) {
@@ -235,7 +243,7 @@ int DataHandle::Request(int index) {
 				ParamReadUsage();
 			}
 			else if (userInput.find("push") != string::npos) {
-				UpdateParam(userInput);
+				UpdateParamToService(userInput);
 			}
 			else {
 				ParamRequest(ConverType::TryToI(userInput));
@@ -264,6 +272,18 @@ void DataHandle::ParamRequest(int index) {
 	if (index == VERSIONRSP) {
 		PushMsg(VERSIONREQ);  //获取版本信息
 	}
+	if (index == SCANERCTRLCFGPARAM) {
+		::stream::ResponseAny resp;
+		stream::ScannerCrtlCfgResp result;
+
+		WriteData wdata{ SCANERCTRLCFG };
+		m_streamClient->Request(wdata, &resp);
+		if (resp.data().Is<stream::ScannerCrtlCfgResp>()) {
+			resp.data().UnpackTo(&result);
+			PrintScanerCfg(result);
+		}
+		index = -1;
+	}
 	else if (index >= PARAMLIMITCFGPARAM && index <= ELECFGPARAM) {
 		PushMsg(REQUEST); 
 	}
@@ -289,8 +309,62 @@ void DataHandle::ParamRequest(int index) {
 }
 
 
+void DataHandle::PrintScanerCfg(const stream::ScannerCrtlCfgResp& result) {
+	result.scannercfg().size();
+	for (auto& rsp : result.scannercfg()) {
+		printf("seqNo:%d\n",rsp.seqno());
+		printf("controlno:%d,serialno:%d,controlType:%d,cardname:%s,cardip:%s,isenable:%d,hadassign:%d,hadmatch:%d\n",
+			rsp.controlno(), rsp.serialno(), rsp.controltype(), rsp.cardname().data(), rsp.cardip().data(), rsp.isenable(), rsp.hadassign(), rsp.hadmatch());
+
+		for (auto& fp : rsp.fixpointdata()) {
+			printf("(pixpoint)id:%d,cno:%d,pointx:%f,pointy:%f,duration:%d\n"
+				, fp.id(), fp.cno(), fp.pointx(), fp.pointy(), fp.duration());
+		}
+
+		//打印部分内容
+		auto& spc = rsp.scanparamcfg();
+		printf("(scanparamcfg)edgelevel:%d,edgelevelmin:%d,edgelevelmax:%d,jumpDelay:%u\n",
+			spc.edgelevel(), spc.edgelevelmin(), spc.edgelevelmax(), spc.jumpdelay());
+		
+		auto& hp = rsp.hatchingparams();
+		printf("(hatchingparams)edgelevel:%d,edgelevelmin:%d,edgelevelmax:%d,jumpDelay:%u\n",
+			hp.edgelevel(), hp.edgelevelmin(), hp.edgelevelmax(), hp.jumpdelay());
+
+		auto& bp = rsp.borderparams();
+		printf("(borderParams)edgelevel:%d,edgelevelmin:%d,edgelevelmax:%d,jumpDelay:%u\n",
+			hp.edgelevel(), hp.edgelevelmin(), hp.edgelevelmax(), hp.jumpdelay());
+
+		auto& sp = rsp.supportparams();
+		printf("(supportparams)edgelevel:%d,edgelevelmin:%d,edgelevelmax:%d,jumpDelay:%u\n",
+			sp.edgelevel(), sp.edgelevelmin(), sp.edgelevelmax(), sp.jumpdelay());
+
+		auto& cpc = rsp.correctparamcfg();
+		printf("(correctparamcfg)xmeasuremin:%.3f,xmeasuremax:%.3f,ymeasuremin:%.3f,ymeasuremax:%.3f\n",
+			cpc.xmeasuremin(), cpc.xmeasuremax(), cpc.ymeasuremin(), cpc.ymeasuremax());
+
+		auto& stc = rsp.scantestcfg();
+		printf("(scantestcfg)debugshape:%d,shapesize:%d,shapesizemin:%d,shape_size_max:%d\n",
+			stc.debugshape(), stc.shapesize(), stc.shapesizemin(), stc.shape_size_max());
+	
+		auto& swc = rsp.skywritingcfg();
+		printf("(skywritingcfg)debugshape:%d,shapesize:%.3f,shapesizemin:%.3f,shape_size_max:%.3f\n",
+			swc.isenable(), swc.timelag(), swc.timelagmin(), swc.timelagmax());
+
+		for (auto& pc : rsp.powercompensate()) {
+			printf("(powercompensate)cno:%d,percent:%d,value:%.3f,value_min:%.3f,value_max:%.3f\n",
+				pc.cno(), pc.percent(), pc.value(), pc.value_min(),pc.value_max());
+		}
+
+		for (auto& tpc : rsp.tpowercompensate()) {
+			printf("(tpowercompensate)cno:%d,id:%d,value:%u,value_min:%u,value_max:%.3f\n",
+				tpc.cno(), tpc.id(), tpc.startminute(), tpc.endminute(), tpc.compensate());
+		}
+	}
+
+}
+
 //选择一个参数更新到服务
-void  DataHandle::UpdateParam(const string& input) {
+void  DataHandle::UpdateParamToService(const string& input) {
 	WriteData writeData;
 	int index = ConverType::TryToI(input.substr(5));
 	switch (index) {
@@ -338,6 +412,8 @@ void  DataHandle::UpdateParam(const string& input) {
 		writeData.items.emplace_back(Item{"","",UNKNOW,"",0,0,0,1,100,2});
 		PushMsg(writeData);
 		break;
+	case SCANERCTRLCFGPARAM:
+		break;
 	case ELECFGPARAM:
 		break;
 	case LOADPARAMRSP:
diff --git a/TestClient/DataManage/DataHandle.h b/TestClient/DataManage/DataHandle.h
index 2a9a707..4b11389 100644
--- a/TestClient/DataManage/DataHandle.h
+++ b/TestClient/DataManage/DataHandle.h
@@ -34,7 +34,7 @@ public:
 	void PurifierTest();  //净化器功能测试
 	void ConfigTest();  //配置功能测试
 
-	void UpdateParam(const string& input);
+	void UpdateParamToService(const string& input);
 
 	void Usage();
 	void ParamReadUsage();
@@ -44,7 +44,7 @@ public:
 private:
 	void DataCallBackHandle(const ReadData& msg);
 	void PrintValue(const ReadData& msg);
-
+	void PrintScanerCfg(const stream::ScannerCrtlCfgResp& result);   //打印config的特殊配置
 private:
 	DataCallBack  m_dataCallBack;
 	StreamClient* m_streamClient;
diff --git a/TestClient/DataManage/RWData.h b/TestClient/DataManage/RWData.h
index 55bf19f..6d91078 100644
--- a/TestClient/DataManage/RWData.h
+++ b/TestClient/DataManage/RWData.h
@@ -51,6 +51,8 @@ enum READTYPE {
     PAUSEALARMCFGPARAM,     //AlarmCfgWrapper pause参数
     WARNALARMCFGPARAM,     //AlarmCfgWrapper warn参数
     POWDERSETPARAM,    //PowderSet 参数
+    SCANNERCONTROLCFGPARAM,    //ScannerControlCfg 参数
+    SCANERCTRLCFGPARAM,     //scanerctrlcfg 参数
 
     MOLDCFGPARAM,
     LOADCFGPARAM,
@@ -103,6 +105,16 @@ struct Item {
     int start_layer;
     int end_layer;
     float powder;
+
+    int seqNo;   //ScannerControlCfg使用
+    int controlNo;
+    int serialNo;
+    int controlType;
+    std::string cardName;
+    std::string cardIP;
+    //bool isEnable;				//是否启动
+    bool hadAssign;
+    bool hadMatch;
 };
 
 struct ReadData {
@@ -145,6 +157,7 @@ enum WRITETYPE {
     COMMUNICATIONCFG,
     ALARMCFG,
     POWDERSET,
+    SCANERCTRLCFG,
 
     LOADPARAM,  //装载参数
     SCANCTRLFUNC,     //振镜控制函数
diff --git a/TestClient/DataManage/StreamClient.cpp b/TestClient/DataManage/StreamClient.cpp
index cb308d6..bc336e9 100644
--- a/TestClient/DataManage/StreamClient.cpp
+++ b/TestClient/DataManage/StreamClient.cpp
@@ -71,11 +71,11 @@ void StreamClient::AllStream() {
         while (!m_readQuitFlag && stream->Read(&readInfo)) {
             ReadData readData;
             readData.dataType = (READTYPE)readInfo.datatype();
-
             for (const ::stream::ParamInfo& it : readInfo.item()) {
                 readData.its.emplace_back(Item{ it.namekey(),it.strvalue(),(DATATYPE)it.valuetype()
                     ,it.context(),it.isenable(),it.isalarm(),it.isshow()
-                    ,it.startlayer(),it.endlayer(),it.powder() });
+                    ,it.startlayer(),it.endlayer(),it.powder(),it.seqno(),it.controlno(),it.serialno()
+                    ,it.controltype(),it.cardname(),it.cardip(),it.hadassign(),it.hadmatch()});
                 //printf("接收到服务端消息：dataType:%d,nameKey:%s, strvalue:%s,valueType:%d\n",
                 //    readData.dataType, it.namekey().data(), it.strvalue().c_str(), it.valuetype());
             }
@@ -110,7 +110,6 @@ void StreamClient::AllStream() {
                 }
 
                 stream->Write(request);
-                //printf("write code:%d\n", ret);
             }
             else {
                 std::this_thread::sleep_for(std::chrono::milliseconds(100));
diff --git a/TestClient/protobuf/stream.pb.cc b/TestClient/protobuf/stream.pb.cc
index 4f1ed96..e7673c2 100644
--- a/TestClient/protobuf/stream.pb.cc
+++ b/TestClient/protobuf/stream.pb.cc
@@ -36,13 +36,27 @@ PROTOBUF_CONSTEXPR ParamInfo::ParamInfo(::_pbi::ConstantInitialized)
           &::_pbi::fixed_address_empty_string,
           ::_pbi::ConstantInitialized{},
       },
+      /*decltype(_impl_.cardname_)*/ {
+          &::_pbi::fixed_address_empty_string,
+          ::_pbi::ConstantInitialized{},
+      },
+      /*decltype(_impl_.cardip_)*/ {
+          &::_pbi::fixed_address_empty_string,
+          ::_pbi::ConstantInitialized{},
+      },
       /*decltype(_impl_.valuetype_)*/ 0,
+      /*decltype(_impl_.startlayer_)*/ 0,
       /*decltype(_impl_.isenable_)*/ false,
       /*decltype(_impl_.isalarm_)*/ false,
       /*decltype(_impl_.isshow_)*/ false,
-      /*decltype(_impl_.startlayer_)*/ 0,
+      /*decltype(_impl_.hadassign_)*/ false,
       /*decltype(_impl_.endlayer_)*/ 0,
       /*decltype(_impl_.powder_)*/ 0,
+      /*decltype(_impl_.seqno_)*/ 0,
+      /*decltype(_impl_.controlno_)*/ 0,
+      /*decltype(_impl_.serialno_)*/ 0,
+      /*decltype(_impl_.controltype_)*/ 0,
+      /*decltype(_impl_.hadmatch_)*/ false,
       /*decltype(_impl_._cached_size_)*/ {},
     } {}
 struct ParamInfoDefaultTypeInternal {
@@ -264,8 +278,280 @@ struct ComResponceDefaultTypeInternal {
 
 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
     PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ComResponceDefaultTypeInternal _ComResponce_default_instance_;
+        template <typename>
+PROTOBUF_CONSTEXPR ScannerCrtlCfgResp::ScannerCrtlCfgResp(::_pbi::ConstantInitialized)
+    : _impl_{
+      /*decltype(_impl_.scannercfg_)*/ {},
+      /*decltype(_impl_._cached_size_)*/ {},
+    } {}
+struct ScannerCrtlCfgRespDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ScannerCrtlCfgRespDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ScannerCrtlCfgRespDefaultTypeInternal() {}
+  union {
+    ScannerCrtlCfgResp _instance;
+  };
+};
+
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
+    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ScannerCrtlCfgRespDefaultTypeInternal _ScannerCrtlCfgResp_default_instance_;
+        template <typename>
+PROTOBUF_CONSTEXPR ScannerCrtlCfgData::ScannerCrtlCfgData(::_pbi::ConstantInitialized)
+    : _impl_{
+      /*decltype(_impl_._has_bits_)*/ {},
+      /*decltype(_impl_._cached_size_)*/ {},
+      /*decltype(_impl_.fixpointdata_)*/ {},
+      /*decltype(_impl_.powercompensate_)*/ {},
+      /*decltype(_impl_.tpowercompensate_)*/ {},
+      /*decltype(_impl_.cardname_)*/ {
+          &::_pbi::fixed_address_empty_string,
+          ::_pbi::ConstantInitialized{},
+      },
+      /*decltype(_impl_.cardip_)*/ {
+          &::_pbi::fixed_address_empty_string,
+          ::_pbi::ConstantInitialized{},
+      },
+      /*decltype(_impl_.scanparamcfg_)*/ nullptr,
+      /*decltype(_impl_.hatchingparams_)*/ nullptr,
+      /*decltype(_impl_.borderparams_)*/ nullptr,
+      /*decltype(_impl_.supportparams_)*/ nullptr,
+      /*decltype(_impl_.correctparamcfg_)*/ nullptr,
+      /*decltype(_impl_.scantestcfg_)*/ nullptr,
+      /*decltype(_impl_.skywritingcfg_)*/ nullptr,
+      /*decltype(_impl_.seqno_)*/ 0,
+      /*decltype(_impl_.controlno_)*/ 0,
+      /*decltype(_impl_.serialno_)*/ 0,
+      /*decltype(_impl_.controltype_)*/ 0,
+      /*decltype(_impl_.isenable_)*/ false,
+      /*decltype(_impl_.hadassign_)*/ false,
+      /*decltype(_impl_.hadmatch_)*/ false,
+    } {}
+struct ScannerCrtlCfgDataDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ScannerCrtlCfgDataDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ScannerCrtlCfgDataDefaultTypeInternal() {}
+  union {
+    ScannerCrtlCfgData _instance;
+  };
+};
+
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
+    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ScannerCrtlCfgDataDefaultTypeInternal _ScannerCrtlCfgData_default_instance_;
+        template <typename>
+PROTOBUF_CONSTEXPR FixPointData::FixPointData(::_pbi::ConstantInitialized)
+    : _impl_{
+      /*decltype(_impl_.id_)*/ 0,
+      /*decltype(_impl_.cno_)*/ 0,
+      /*decltype(_impl_.pointx_)*/ 0,
+      /*decltype(_impl_.pointy_)*/ 0,
+      /*decltype(_impl_.duration_)*/ 0u,
+      /*decltype(_impl_._cached_size_)*/ {},
+    } {}
+struct FixPointDataDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR FixPointDataDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
+  ~FixPointDataDefaultTypeInternal() {}
+  union {
+    FixPointData _instance;
+  };
+};
+
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
+    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FixPointDataDefaultTypeInternal _FixPointData_default_instance_;
+        template <typename>
+PROTOBUF_CONSTEXPR ScanParamCfg::ScanParamCfg(::_pbi::ConstantInitialized)
+    : _impl_{
+      /*decltype(_impl_.edgelevel_)*/ 0,
+      /*decltype(_impl_.edgelevelmin_)*/ 0,
+      /*decltype(_impl_.edgelevelmax_)*/ 0,
+      /*decltype(_impl_.jumpdelay_)*/ 0u,
+      /*decltype(_impl_.jumpdelaymin_)*/ 0u,
+      /*decltype(_impl_.jumpdelaymax_)*/ 0u,
+      /*decltype(_impl_.scandelay_)*/ 0u,
+      /*decltype(_impl_.scandelaymin_)*/ 0u,
+      /*decltype(_impl_.scandelaymax_)*/ 0u,
+      /*decltype(_impl_.polygondelay_)*/ 0u,
+      /*decltype(_impl_.polygondelaymin_)*/ 0u,
+      /*decltype(_impl_.polygondelaymax_)*/ 0u,
+      /*decltype(_impl_.laseroffdelay_)*/ ::int64_t{0},
+      /*decltype(_impl_.laseroffdelaymin_)*/ ::int64_t{0},
+      /*decltype(_impl_.laseroffdelaymax_)*/ ::int64_t{0},
+      /*decltype(_impl_.laserondelay_)*/ ::int64_t{0},
+      /*decltype(_impl_.laserondelaymin_)*/ ::int64_t{0},
+      /*decltype(_impl_.laserondelaymax_)*/ ::int64_t{0},
+      /*decltype(_impl_.minjumpdelay_)*/ 0u,
+      /*decltype(_impl_.minjumpdelaymin_)*/ 0u,
+      /*decltype(_impl_.minjumpdelaymax_)*/ 0u,
+      /*decltype(_impl_.jumplengthlimit_)*/ 0u,
+      /*decltype(_impl_.jumplengthlimitmin_)*/ 0u,
+      /*decltype(_impl_.jumplengthlimitmax_)*/ 0u,
+      /*decltype(_impl_.jumpspeed_)*/ 0,
+      /*decltype(_impl_.jumpspeedmin_)*/ 0,
+      /*decltype(_impl_.jumpspeedmax_)*/ 0,
+      /*decltype(_impl_.markspeed_)*/ 0,
+      /*decltype(_impl_.markspeedmin_)*/ 0,
+      /*decltype(_impl_.markspeedmax_)*/ 0,
+      /*decltype(_impl_._cached_size_)*/ {},
+    } {}
+struct ScanParamCfgDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ScanParamCfgDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ScanParamCfgDefaultTypeInternal() {}
+  union {
+    ScanParamCfg _instance;
+  };
+};
+
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
+    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ScanParamCfgDefaultTypeInternal _ScanParamCfg_default_instance_;
+        template <typename>
+PROTOBUF_CONSTEXPR CorrectParamCfg::CorrectParamCfg(::_pbi::ConstantInitialized)
+    : _impl_{
+      /*decltype(_impl_.xmeasuremin_)*/ 0,
+      /*decltype(_impl_.xmeasuremax_)*/ 0,
+      /*decltype(_impl_.ymeasuremin_)*/ 0,
+      /*decltype(_impl_.ymeasuremax_)*/ 0,
+      /*decltype(_impl_.xposfix_)*/ 0,
+      /*decltype(_impl_.yposfix_)*/ 0,
+      /*decltype(_impl_.scanangle_)*/ 0,
+      /*decltype(_impl_.scananglemin_)*/ 0,
+      /*decltype(_impl_.scananglemax_)*/ 0,
+      /*decltype(_impl_.fixangle_)*/ 0,
+      /*decltype(_impl_.fixanglemin_)*/ 0,
+      /*decltype(_impl_.fixanglemax_)*/ 0,
+      /*decltype(_impl_.xcorrect_)*/ 0,
+      /*decltype(_impl_.ycorrect_)*/ 0,
+      /*decltype(_impl_.xcorrectmin_)*/ 0,
+      /*decltype(_impl_.xcorrectmax_)*/ 0,
+      /*decltype(_impl_.ycorrectmin_)*/ 0,
+      /*decltype(_impl_.ycorrectmax_)*/ 0,
+      /*decltype(_impl_.realxoffset_)*/ 0,
+      /*decltype(_impl_.realyoffset_)*/ 0,
+      /*decltype(_impl_.factork_)*/ 0,
+      /*decltype(_impl_.defocusratio_)*/ 0,
+      /*decltype(_impl_.defocusratiomin_)*/ 0,
+      /*decltype(_impl_.defocusratiomax_)*/ 0,
+      /*decltype(_impl_.iscorrectfile3d_)*/ false,
+      /*decltype(_impl_.isdynamicfocus_)*/ false,
+      /*decltype(_impl_._cached_size_)*/ {},
+    } {}
+struct CorrectParamCfgDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR CorrectParamCfgDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
+  ~CorrectParamCfgDefaultTypeInternal() {}
+  union {
+    CorrectParamCfg _instance;
+  };
+};
+
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
+    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CorrectParamCfgDefaultTypeInternal _CorrectParamCfg_default_instance_;
+        template <typename>
+PROTOBUF_CONSTEXPR ScanTestCfg::ScanTestCfg(::_pbi::ConstantInitialized)
+    : _impl_{
+      /*decltype(_impl_.debugshape_)*/ 0,
+      /*decltype(_impl_.shapesize_)*/ 0,
+      /*decltype(_impl_.shapesizemin_)*/ 0,
+      /*decltype(_impl_.shape_size_max_)*/ 0,
+      /*decltype(_impl_.laser_power_)*/ 0,
+      /*decltype(_impl_.laser_power_min_)*/ 0,
+      /*decltype(_impl_.defocus_)*/ 0,
+      /*decltype(_impl_.defocus_min_)*/ 0,
+      /*decltype(_impl_.defocus_max_)*/ 0,
+      /*decltype(_impl_.laser_power_max_)*/ 0,
+      /*decltype(_impl_.is_cycle_)*/ false,
+      /*decltype(_impl_.isautoheatingscanner_)*/ false,
+      /*decltype(_impl_.cross_x_)*/ 0,
+      /*decltype(_impl_.cross_y_)*/ 0,
+      /*decltype(_impl_.z_distance_)*/ 0,
+      /*decltype(_impl_.autoheatingscannerminutes_)*/ 0u,
+      /*decltype(_impl_.autoheatingscannersize_)*/ 0u,
+      /*decltype(_impl_.autoheatingscannerspeed_)*/ 0,
+      /*decltype(_impl_.mark_test_start_x_)*/ 0,
+      /*decltype(_impl_.mark_test_start_y_)*/ 0,
+      /*decltype(_impl_.mark_test_end_x_)*/ 0,
+      /*decltype(_impl_.mark_test_end_y_)*/ 0,
+      /*decltype(_impl_._cached_size_)*/ {},
+    } {}
+struct ScanTestCfgDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ScanTestCfgDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ScanTestCfgDefaultTypeInternal() {}
+  union {
+    ScanTestCfg _instance;
+  };
+};
+
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
+    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ScanTestCfgDefaultTypeInternal _ScanTestCfg_default_instance_;
+        template <typename>
+PROTOBUF_CONSTEXPR SkyWritingCfg::SkyWritingCfg(::_pbi::ConstantInitialized)
+    : _impl_{
+      /*decltype(_impl_.timelag_)*/ 0,
+      /*decltype(_impl_.timelagmin_)*/ 0,
+      /*decltype(_impl_.timelagmax_)*/ 0,
+      /*decltype(_impl_.isenable_)*/ false,
+      /*decltype(_impl_.nprev_)*/ 0u,
+      /*decltype(_impl_.laseronshift_)*/ ::int64_t{0},
+      /*decltype(_impl_.laseronshiftmin_)*/ ::int64_t{0},
+      /*decltype(_impl_.laseronshiftmax_)*/ ::int64_t{0},
+      /*decltype(_impl_.nprevmin_)*/ 0u,
+      /*decltype(_impl_.nprevmax_)*/ 0u,
+      /*decltype(_impl_.npost_)*/ 0u,
+      /*decltype(_impl_.npostmin_)*/ 0u,
+      /*decltype(_impl_.npostmax_)*/ 0u,
+      /*decltype(_impl_.mode_)*/ 0,
+      /*decltype(_impl_.limite_)*/ 0,
+      /*decltype(_impl_.limitemin_)*/ 0,
+      /*decltype(_impl_.limitemax_)*/ 0,
+      /*decltype(_impl_._cached_size_)*/ {},
+    } {}
+struct SkyWritingCfgDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR SkyWritingCfgDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
+  ~SkyWritingCfgDefaultTypeInternal() {}
+  union {
+    SkyWritingCfg _instance;
+  };
+};
+
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
+    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SkyWritingCfgDefaultTypeInternal _SkyWritingCfg_default_instance_;
+        template <typename>
+PROTOBUF_CONSTEXPR PowerCompensate::PowerCompensate(::_pbi::ConstantInitialized)
+    : _impl_{
+      /*decltype(_impl_.cno_)*/ 0,
+      /*decltype(_impl_.percent_)*/ 0,
+      /*decltype(_impl_.value_)*/ 0,
+      /*decltype(_impl_.value_min_)*/ 0,
+      /*decltype(_impl_.value_max_)*/ 0,
+      /*decltype(_impl_._cached_size_)*/ {},
+    } {}
+struct PowerCompensateDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR PowerCompensateDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
+  ~PowerCompensateDefaultTypeInternal() {}
+  union {
+    PowerCompensate _instance;
+  };
+};
+
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
+    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PowerCompensateDefaultTypeInternal _PowerCompensate_default_instance_;
+        template <typename>
+PROTOBUF_CONSTEXPR TimePowerCompensate::TimePowerCompensate(::_pbi::ConstantInitialized)
+    : _impl_{
+      /*decltype(_impl_.id_)*/ 0,
+      /*decltype(_impl_.cno_)*/ 0,
+      /*decltype(_impl_.startminute_)*/ 0u,
+      /*decltype(_impl_.endminute_)*/ 0u,
+      /*decltype(_impl_.compensate_)*/ 0,
+      /*decltype(_impl_._cached_size_)*/ {},
+    } {}
+struct TimePowerCompensateDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR TimePowerCompensateDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
+  ~TimePowerCompensateDefaultTypeInternal() {}
+  union {
+    TimePowerCompensate _instance;
+  };
+};
+
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
+    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TimePowerCompensateDefaultTypeInternal _TimePowerCompensate_default_instance_;
 }  // namespace stream
-static ::_pb::Metadata file_level_metadata_stream_2eproto[12];
+static ::_pb::Metadata file_level_metadata_stream_2eproto[21];
 static const ::_pb::EnumDescriptor* file_level_enum_descriptors_stream_2eproto[2];
 static constexpr const ::_pb::ServiceDescriptor**
     file_level_service_descriptors_stream_2eproto = nullptr;
@@ -289,6 +575,14 @@ const ::uint32_t TableStruct_stream_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE
     PROTOBUF_FIELD_OFFSET(::stream::ParamInfo, _impl_.startlayer_),
     PROTOBUF_FIELD_OFFSET(::stream::ParamInfo, _impl_.endlayer_),
     PROTOBUF_FIELD_OFFSET(::stream::ParamInfo, _impl_.powder_),
+    PROTOBUF_FIELD_OFFSET(::stream::ParamInfo, _impl_.seqno_),
+    PROTOBUF_FIELD_OFFSET(::stream::ParamInfo, _impl_.controlno_),
+    PROTOBUF_FIELD_OFFSET(::stream::ParamInfo, _impl_.serialno_),
+    PROTOBUF_FIELD_OFFSET(::stream::ParamInfo, _impl_.controltype_),
+    PROTOBUF_FIELD_OFFSET(::stream::ParamInfo, _impl_.cardname_),
+    PROTOBUF_FIELD_OFFSET(::stream::ParamInfo, _impl_.cardip_),
+    PROTOBUF_FIELD_OFFSET(::stream::ParamInfo, _impl_.hadassign_),
+    PROTOBUF_FIELD_OFFSET(::stream::ParamInfo, _impl_.hadmatch_),
     ~0u,  // no _has_bits_
     PROTOBUF_FIELD_OFFSET(::stream::RequestInfo, _internal_metadata_),
     ~0u,  // no _extensions_
@@ -412,22 +706,252 @@ const ::uint32_t TableStruct_stream_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE
     ~0u,  // no _split_
     ~0u,  // no sizeof(Split)
     PROTOBUF_FIELD_OFFSET(::stream::ComResponce, _impl_.data_),
+    ~0u,  // no _has_bits_
+    PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgResp, _internal_metadata_),
+    ~0u,  // no _extensions_
+    ~0u,  // no _oneof_case_
+    ~0u,  // no _weak_field_map_
+    ~0u,  // no _inlined_string_donated_
+    ~0u,  // no _split_
+    ~0u,  // no sizeof(Split)
+    PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgResp, _impl_.scannercfg_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_._has_bits_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _internal_metadata_),
+    ~0u,  // no _extensions_
+    ~0u,  // no _oneof_case_
+    ~0u,  // no _weak_field_map_
+    ~0u,  // no _inlined_string_donated_
+    ~0u,  // no _split_
+    ~0u,  // no sizeof(Split)
+    PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.seqno_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.fixpointdata_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.scanparamcfg_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.hatchingparams_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.borderparams_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.supportparams_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.correctparamcfg_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.scantestcfg_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.skywritingcfg_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.powercompensate_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.tpowercompensate_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.controlno_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.serialno_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.controltype_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.cardname_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.cardip_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.isenable_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.hadassign_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScannerCrtlCfgData, _impl_.hadmatch_),
+    ~0u,
+    ~0u,
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    ~0u,
+    ~0u,
+    ~0u,
+    ~0u,
+    ~0u,
+    ~0u,
+    ~0u,
+    ~0u,
+    ~0u,
+    ~0u,
+    ~0u,  // no _has_bits_
+    PROTOBUF_FIELD_OFFSET(::stream::FixPointData, _internal_metadata_),
+    ~0u,  // no _extensions_
+    ~0u,  // no _oneof_case_
+    ~0u,  // no _weak_field_map_
+    ~0u,  // no _inlined_string_donated_
+    ~0u,  // no _split_
+    ~0u,  // no sizeof(Split)
+    PROTOBUF_FIELD_OFFSET(::stream::FixPointData, _impl_.id_),
+    PROTOBUF_FIELD_OFFSET(::stream::FixPointData, _impl_.cno_),
+    PROTOBUF_FIELD_OFFSET(::stream::FixPointData, _impl_.pointx_),
+    PROTOBUF_FIELD_OFFSET(::stream::FixPointData, _impl_.pointy_),
+    PROTOBUF_FIELD_OFFSET(::stream::FixPointData, _impl_.duration_),
+    ~0u,  // no _has_bits_
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _internal_metadata_),
+    ~0u,  // no _extensions_
+    ~0u,  // no _oneof_case_
+    ~0u,  // no _weak_field_map_
+    ~0u,  // no _inlined_string_donated_
+    ~0u,  // no _split_
+    ~0u,  // no sizeof(Split)
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.edgelevel_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.edgelevelmin_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.edgelevelmax_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.jumpdelay_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.jumpdelaymin_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.jumpdelaymax_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.scandelay_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.scandelaymin_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.scandelaymax_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.polygondelay_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.polygondelaymin_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.polygondelaymax_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.laseroffdelay_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.laseroffdelaymin_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.laseroffdelaymax_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.laserondelay_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.laserondelaymin_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.laserondelaymax_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.minjumpdelay_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.minjumpdelaymin_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.minjumpdelaymax_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.jumplengthlimit_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.jumplengthlimitmin_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.jumplengthlimitmax_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.jumpspeed_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.jumpspeedmin_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.jumpspeedmax_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.markspeed_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.markspeedmin_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanParamCfg, _impl_.markspeedmax_),
+    ~0u,  // no _has_bits_
+    PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _internal_metadata_),
+    ~0u,  // no _extensions_
+    ~0u,  // no _oneof_case_
+    ~0u,  // no _weak_field_map_
+    ~0u,  // no _inlined_string_donated_
+    ~0u,  // no _split_
+    ~0u,  // no sizeof(Split)
+    PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.xmeasuremin_),
+    PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.xmeasuremax_),
+    PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.ymeasuremin_),
+    PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.ymeasuremax_),
+    PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.xposfix_),
+    PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.yposfix_),
+    PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.scanangle_),
+    PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.scananglemin_),
+    PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.scananglemax_),
+    PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.fixangle_),
+    PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.fixanglemin_),
+    PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.fixanglemax_),
+    PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.xcorrect_),
+    PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.ycorrect_),
+    PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.xcorrectmin_),
+    PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.xcorrectmax_),
+    PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.ycorrectmin_),
+    PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.ycorrectmax_),
+    PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.realxoffset_),
+    PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.realyoffset_),
+    PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.factork_),
+    PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.iscorrectfile3d_),
+    PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.isdynamicfocus_),
+    PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.defocusratio_),
+    PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.defocusratiomin_),
+    PROTOBUF_FIELD_OFFSET(::stream::CorrectParamCfg, _impl_.defocusratiomax_),
+    ~0u,  // no _has_bits_
+    PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _internal_metadata_),
+    ~0u,  // no _extensions_
+    ~0u,  // no _oneof_case_
+    ~0u,  // no _weak_field_map_
+    ~0u,  // no _inlined_string_donated_
+    ~0u,  // no _split_
+    ~0u,  // no sizeof(Split)
+    PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.debugshape_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.shapesize_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.shapesizemin_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.shape_size_max_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.laser_power_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.laser_power_min_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.laser_power_max_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.defocus_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.defocus_min_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.defocus_max_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.is_cycle_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.cross_x_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.cross_y_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.z_distance_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.isautoheatingscanner_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.autoheatingscannerminutes_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.autoheatingscannersize_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.autoheatingscannerspeed_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.mark_test_start_x_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.mark_test_start_y_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.mark_test_end_x_),
+    PROTOBUF_FIELD_OFFSET(::stream::ScanTestCfg, _impl_.mark_test_end_y_),
+    ~0u,  // no _has_bits_
+    PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _internal_metadata_),
+    ~0u,  // no _extensions_
+    ~0u,  // no _oneof_case_
+    ~0u,  // no _weak_field_map_
+    ~0u,  // no _inlined_string_donated_
+    ~0u,  // no _split_
+    ~0u,  // no sizeof(Split)
+    PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.isenable_),
+    PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.timelag_),
+    PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.timelagmin_),
+    PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.timelagmax_),
+    PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.laseronshift_),
+    PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.laseronshiftmin_),
+    PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.laseronshiftmax_),
+    PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.nprev_),
+    PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.nprevmin_),
+    PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.nprevmax_),
+    PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.npost_),
+    PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.npostmin_),
+    PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.npostmax_),
+    PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.mode_),
+    PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.limite_),
+    PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.limitemin_),
+    PROTOBUF_FIELD_OFFSET(::stream::SkyWritingCfg, _impl_.limitemax_),
+    ~0u,  // no _has_bits_
+    PROTOBUF_FIELD_OFFSET(::stream::PowerCompensate, _internal_metadata_),
+    ~0u,  // no _extensions_
+    ~0u,  // no _oneof_case_
+    ~0u,  // no _weak_field_map_
+    ~0u,  // no _inlined_string_donated_
+    ~0u,  // no _split_
+    ~0u,  // no sizeof(Split)
+    PROTOBUF_FIELD_OFFSET(::stream::PowerCompensate, _impl_.cno_),
+    PROTOBUF_FIELD_OFFSET(::stream::PowerCompensate, _impl_.percent_),
+    PROTOBUF_FIELD_OFFSET(::stream::PowerCompensate, _impl_.value_),
+    PROTOBUF_FIELD_OFFSET(::stream::PowerCompensate, _impl_.value_min_),
+    PROTOBUF_FIELD_OFFSET(::stream::PowerCompensate, _impl_.value_max_),
+    ~0u,  // no _has_bits_
+    PROTOBUF_FIELD_OFFSET(::stream::TimePowerCompensate, _internal_metadata_),
+    ~0u,  // no _extensions_
+    ~0u,  // no _oneof_case_
+    ~0u,  // no _weak_field_map_
+    ~0u,  // no _inlined_string_donated_
+    ~0u,  // no _split_
+    ~0u,  // no sizeof(Split)
+    PROTOBUF_FIELD_OFFSET(::stream::TimePowerCompensate, _impl_.id_),
+    PROTOBUF_FIELD_OFFSET(::stream::TimePowerCompensate, _impl_.cno_),
+    PROTOBUF_FIELD_OFFSET(::stream::TimePowerCompensate, _impl_.startminute_),
+    PROTOBUF_FIELD_OFFSET(::stream::TimePowerCompensate, _impl_.endminute_),
+    PROTOBUF_FIELD_OFFSET(::stream::TimePowerCompensate, _impl_.compensate_),
 };
 
 static const ::_pbi::MigrationSchema
     schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
         {0, -1, -1, sizeof(::stream::ParamInfo)},
-        {18, -1, -1, sizeof(::stream::RequestInfo)},
-        {32, -1, -1, sizeof(::stream::ResponseInfo)},
-        {43, 52, -1, sizeof(::stream::ResponseAny)},
-        {53, -1, -1, sizeof(::stream::LayerData)},
-        {66, -1, -1, sizeof(::stream::LayerDataBlock)},
-        {80, -1, -1, sizeof(::stream::VectorDataBlock)},
-        {92, -1, -1, sizeof(::stream::ChainDataBlock)},
-        {102, -1, -1, sizeof(::stream::Point)},
-        {112, -1, -1, sizeof(::stream::RegResponce)},
-        {121, -1, -1, sizeof(::stream::ImgInfoResponce)},
-        {132, -1, -1, sizeof(::stream::ComResponce)},
+        {26, -1, -1, sizeof(::stream::RequestInfo)},
+        {40, -1, -1, sizeof(::stream::ResponseInfo)},
+        {51, 60, -1, sizeof(::stream::ResponseAny)},
+        {61, -1, -1, sizeof(::stream::LayerData)},
+        {74, -1, -1, sizeof(::stream::LayerDataBlock)},
+        {88, -1, -1, sizeof(::stream::VectorDataBlock)},
+        {100, -1, -1, sizeof(::stream::ChainDataBlock)},
+        {110, -1, -1, sizeof(::stream::Point)},
+        {120, -1, -1, sizeof(::stream::RegResponce)},
+        {129, -1, -1, sizeof(::stream::ImgInfoResponce)},
+        {140, -1, -1, sizeof(::stream::ComResponce)},
+        {149, -1, -1, sizeof(::stream::ScannerCrtlCfgResp)},
+        {158, 185, -1, sizeof(::stream::ScannerCrtlCfgData)},
+        {204, -1, -1, sizeof(::stream::FixPointData)},
+        {217, -1, -1, sizeof(::stream::ScanParamCfg)},
+        {255, -1, -1, sizeof(::stream::CorrectParamCfg)},
+        {289, -1, -1, sizeof(::stream::ScanTestCfg)},
+        {319, -1, -1, sizeof(::stream::SkyWritingCfg)},
+        {344, -1, -1, sizeof(::stream::PowerCompensate)},
+        {357, -1, -1, sizeof(::stream::TimePowerCompensate)},
 };
 
 static const ::_pb::Message* const file_default_instances[] = {
@@ -443,51 +967,143 @@ static const ::_pb::Message* const file_default_instances[] = {
     &::stream::_RegResponce_default_instance_._instance,
     &::stream::_ImgInfoResponce_default_instance_._instance,
     &::stream::_ComResponce_default_instance_._instance,
+    &::stream::_ScannerCrtlCfgResp_default_instance_._instance,
+    &::stream::_ScannerCrtlCfgData_default_instance_._instance,
+    &::stream::_FixPointData_default_instance_._instance,
+    &::stream::_ScanParamCfg_default_instance_._instance,
+    &::stream::_CorrectParamCfg_default_instance_._instance,
+    &::stream::_ScanTestCfg_default_instance_._instance,
+    &::stream::_SkyWritingCfg_default_instance_._instance,
+    &::stream::_PowerCompensate_default_instance_._instance,
+    &::stream::_TimePowerCompensate_default_instance_._instance,
 };
 const char descriptor_table_protodef_stream_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
     "\n\014stream.proto\022\006stream\032\031google/protobuf/"
-    "any.proto\"\311\001\n\tParamInfo\022\017\n\007nameKey\030\001 \001(\014"
+    "any.proto\"\331\002\n\tParamInfo\022\017\n\007nameKey\030\001 \001(\014"
     "\022\020\n\010strValue\030\002 \001(\014\022\037\n\tvalueType\030\003 \001(\0162\014."
     "stream.TYPE\022\017\n\007context\030\004 \001(\014\022\020\n\010isEnable"
     "\030\005 \001(\010\022\017\n\007isAlarm\030\006 \001(\010\022\016\n\006isShow\030\007 \001(\010\022"
     "\022\n\nstartLayer\030\010 \001(\005\022\020\n\010endLayer\030\t \001(\005\022\016\n"
-    "\006powder\030\n \001(\002\"\254\001\n\013RequestInfo\022\020\n\010dataTyp"
-    "e\030\001 \001(\r\022\017\n\007nameKey\030\002 \001(\014\022\020\n\010strValue\030\003 \001"
-    "(\014\022\037\n\tvalueType\030\004 \001(\0162\014.stream.TYPE\022&\n\nh"
-    "andleType\030\005 \001(\0162\022.stream.DATAHANDLE\022\037\n\004i"
-    "tem\030\006 \003(\0132\021.stream.ParamInfo\"Q\n\014Response"
-    "Info\022\020\n\010dataType\030\001 \001(\r\022\016\n\006result\030\002 \001(\010\022\037"
-    "\n\004item\030\003 \003(\0132\021.stream.ParamInfo\"1\n\013Respo"
-    "nseAny\022\"\n\004data\030\001 \001(\0132\024.google.protobuf.A"
-    "ny\"\210\001\n\tLayerData\022\023\n\013zCooldinate\030\001 \001(\002\022\016\n"
-    "\006powder\030\002 \001(\002\022\026\n\016layerThickness\030\003 \001(\002\022.\n"
-    "\016layerDataBlock\030\004 \003(\0132\026.stream.LayerData"
-    "Block\022\016\n\006result\030\005 \001(\010\"\266\001\n\016LayerDataBlock"
-    "\022\021\n\telementId\030\001 \001(\005\022\026\n\016elementParamId\030\002 "
-    "\001(\005\022\021\n\tblockType\030\003 \001(\r\022*\n\tvecBlocks\030\004 \003("
-    "\0132\027.stream.VectorDataBlock\022+\n\013chainBlock"
-    "s\030\005 \003(\0132\026.stream.ChainDataBlock\022\r\n\005order"
-    "\030\006 \001(\r\"M\n\017VectorDataBlock\022\016\n\006startX\030\001 \001("
-    "\002\022\016\n\006startY\030\002 \001(\002\022\014\n\004endX\030\003 \001(\002\022\014\n\004endY\030"
-    "\004 \001(\002\"A\n\016ChainDataBlock\022\016\n\006dotNum\030\001 \001(\r\022"
-    "\037\n\010pointVec\030\002 \003(\0132\r.stream.Point\"#\n\005Poin"
-    "t\022\014\n\004xPos\030\001 \001(\002\022\014\n\004yPos\030\002 \001(\002\"\033\n\013RegResp"
-    "once\022\014\n\004data\030\001 \001(\005\"D\n\017ImgInfoResponce\022\022\n"
-    "\nlevelImage\030\001 \001(\r\022\r\n\005width\030\002 \001(\005\022\016\n\006heig"
-    "ht\030\003 \001(\005\"\033\n\013ComResponce\022\014\n\004data\030\001 \001(\014*\223\001"
-    "\n\004TYPE\022\t\n\005iBOOL\020\000\022\n\n\006iSHORT\020\001\022\013\n\007iUSHORT"
-    "\020\002\022\010\n\004iINT\020\003\022\t\n\005iUINT\020\004\022\n\n\006iFLOAT\020\005\022\013\n\007i"
-    "STRING\020\006\022\t\n\005iCHAR\020\007\022\n\n\006iUCHAR\020\010\022\t\n\005iWORD"
-    "\020\t\022\013\n\007iDOUBLE\020\n\022\n\n\006iTIMET\020\013**\n\nDATAHANDL"
-    "E\022\n\n\006UPDATE\020\000\022\007\n\003ADD\020\001\022\007\n\003DEL\020\0022\372\001\n\006Stre"
-    "am\0224\n\006Simple\022\023.stream.RequestInfo\032\023.stre"
-    "am.ResponseAny\"\000\022=\n\014ServerStream\022\023.strea"
-    "m.RequestInfo\032\024.stream.ResponseInfo\"\0000\001\022"
-    "=\n\014ClientStream\022\023.stream.RequestInfo\032\024.s"
-    "tream.ResponseInfo\"\000(\001\022<\n\tAllStream\022\023.st"
-    "ream.RequestInfo\032\024.stream.ResponseInfo\"\000"
-    "(\0010\001B-\n\027io.grpc.examples.streamB\013StreamP"
-    "rotoP\001\242\002\002STb\006proto3"
+    "\006powder\030\n \001(\002\022\r\n\005seqNo\030\013 \001(\005\022\021\n\tcontrolN"
+    "o\030\014 \001(\005\022\020\n\010serialNo\030\r \001(\005\022\023\n\013controlType"
+    "\030\016 \001(\005\022\020\n\010cardName\030\017 \001(\014\022\016\n\006cardIP\030\020 \001(\014"
+    "\022\021\n\thadAssign\030\021 \001(\010\022\020\n\010hadMatch\030\022 \001(\010\"\254\001"
+    "\n\013RequestInfo\022\020\n\010dataType\030\001 \001(\r\022\017\n\007nameK"
+    "ey\030\002 \001(\014\022\020\n\010strValue\030\003 \001(\014\022\037\n\tvalueType\030"
+    "\004 \001(\0162\014.stream.TYPE\022&\n\nhandleType\030\005 \001(\0162"
+    "\022.stream.DATAHANDLE\022\037\n\004item\030\006 \003(\0132\021.stre"
+    "am.ParamInfo\"Q\n\014ResponseInfo\022\020\n\010dataType"
+    "\030\001 \001(\r\022\016\n\006result\030\002 \001(\010\022\037\n\004item\030\003 \003(\0132\021.s"
+    "tream.ParamInfo\"1\n\013ResponseAny\022\"\n\004data\030\001"
+    " \001(\0132\024.google.protobuf.Any\"\210\001\n\tLayerData"
+    "\022\023\n\013zCooldinate\030\001 \001(\002\022\016\n\006powder\030\002 \001(\002\022\026\n"
+    "\016layerThickness\030\003 \001(\002\022.\n\016layerDataBlock\030"
+    "\004 \003(\0132\026.stream.LayerDataBlock\022\016\n\006result\030"
+    "\005 \001(\010\"\266\001\n\016LayerDataBlock\022\021\n\telementId\030\001 "
+    "\001(\005\022\026\n\016elementParamId\030\002 \001(\005\022\021\n\tblockType"
+    "\030\003 \001(\r\022*\n\tvecBlocks\030\004 \003(\0132\027.stream.Vecto"
+    "rDataBlock\022+\n\013chainBlocks\030\005 \003(\0132\026.stream"
+    ".ChainDataBlock\022\r\n\005order\030\006 \001(\r\"M\n\017Vector"
+    "DataBlock\022\016\n\006startX\030\001 \001(\002\022\016\n\006startY\030\002 \001("
+    "\002\022\014\n\004endX\030\003 \001(\002\022\014\n\004endY\030\004 \001(\002\"A\n\016ChainDa"
+    "taBlock\022\016\n\006dotNum\030\001 \001(\r\022\037\n\010pointVec\030\002 \003("
+    "\0132\r.stream.Point\"#\n\005Point\022\014\n\004xPos\030\001 \001(\002\022"
+    "\014\n\004yPos\030\002 \001(\002\"\033\n\013RegResponce\022\014\n\004data\030\001 \001"
+    "(\005\"D\n\017ImgInfoResponce\022\022\n\nlevelImage\030\001 \001("
+    "\r\022\r\n\005width\030\002 \001(\005\022\016\n\006height\030\003 \001(\005\"\033\n\013ComR"
+    "esponce\022\014\n\004data\030\001 \001(\014\"D\n\022ScannerCrtlCfgR"
+    "esp\022.\n\nscannerCfg\030\001 \003(\0132\032.stream.Scanner"
+    "CrtlCfgData\"\210\005\n\022ScannerCrtlCfgData\022\r\n\005se"
+    "qNo\030\001 \001(\005\022*\n\014fixPointData\030\002 \003(\0132\024.stream"
+    ".FixPointData\022*\n\014scanParamCfg\030\003 \001(\0132\024.st"
+    "ream.ScanParamCfg\022,\n\016hatchingParams\030\004 \001("
+    "\0132\024.stream.ScanParamCfg\022*\n\014borderParams\030"
+    "\005 \001(\0132\024.stream.ScanParamCfg\022+\n\rsupportPa"
+    "rams\030\006 \001(\0132\024.stream.ScanParamCfg\0220\n\017corr"
+    "ectParamCfg\030\007 \001(\0132\027.stream.CorrectParamC"
+    "fg\022(\n\013scanTestCfg\030\010 \001(\0132\023.stream.ScanTes"
+    "tCfg\022,\n\rskyWritingCfg\030\t \001(\0132\025.stream.Sky"
+    "WritingCfg\0220\n\017powerCompensate\030\n \003(\0132\027.st"
+    "ream.PowerCompensate\0225\n\020tPowerCompensate"
+    "\030\013 \003(\0132\033.stream.TimePowerCompensate\022\021\n\tc"
+    "ontrolNo\030\014 \001(\005\022\020\n\010serialNo\030\r \001(\005\022\023\n\013cont"
+    "rolType\030\016 \001(\005\022\020\n\010cardName\030\017 \001(\014\022\016\n\006cardI"
+    "P\030\020 \001(\014\022\020\n\010isEnable\030\021 \001(\010\022\021\n\thadAssign\030\022"
+    " \001(\010\022\020\n\010hadMatch\030\023 \001(\010\"Y\n\014FixPointData\022\n"
+    "\n\002id\030\001 \001(\005\022\013\n\003cno\030\002 \001(\005\022\016\n\006pointX\030\003 \001(\002\022"
+    "\016\n\006pointY\030\004 \001(\002\022\020\n\010duration\030\005 \001(\r\"\275\005\n\014Sc"
+    "anParamCfg\022\021\n\tedgeLevel\030\001 \001(\005\022\024\n\014edgeLev"
+    "elMin\030\002 \001(\005\022\024\n\014edgeLevelMax\030\003 \001(\005\022\021\n\tjum"
+    "pDelay\030\004 \001(\r\022\024\n\014jumpDelayMin\030\005 \001(\r\022\024\n\014ju"
+    "mpDelayMax\030\006 \001(\r\022\021\n\tscanDelay\030\007 \001(\r\022\024\n\014s"
+    "canDelayMin\030\010 \001(\r\022\024\n\014scanDelayMax\030\t \001(\r\022"
+    "\024\n\014polygonDelay\030\n \001(\r\022\027\n\017polygonDelayMin"
+    "\030\013 \001(\r\022\027\n\017polygonDelayMax\030\014 \001(\r\022\025\n\rlaser"
+    "offDelay\030\r \001(\003\022\030\n\020laseroffDelayMin\030\016 \001(\003"
+    "\022\030\n\020laseroffDelayMax\030\017 \001(\003\022\024\n\014laseronDel"
+    "ay\030\020 \001(\003\022\027\n\017laseronDelayMin\030\021 \001(\003\022\027\n\017las"
+    "eronDelayMax\030\022 \001(\003\022\024\n\014minJumpDelay\030\023 \001(\r"
+    "\022\027\n\017minJumpDelayMin\030\024 \001(\r\022\027\n\017minJumpDela"
+    "yMax\030\025 \001(\r\022\027\n\017jumpLengthLimit\030\026 \001(\r\022\032\n\022j"
+    "umpLengthLimitMin\030\027 \001(\r\022\032\n\022jumpLengthLim"
+    "itMax\030\030 \001(\r\022\021\n\tjumpSpeed\030\031 \001(\001\022\024\n\014jumpSp"
+    "eedMin\030\032 \001(\001\022\024\n\014jumpSpeedMax\030\033 \001(\001\022\021\n\tma"
+    "rkSpeed\030\034 \001(\001\022\024\n\014markSpeedMin\030\035 \001(\001\022\024\n\014m"
+    "arkSpeedMax\030\036 \001(\001\"\256\004\n\017CorrectParamCfg\022\023\n"
+    "\013xmeasureMin\030\001 \001(\001\022\023\n\013xmeasureMax\030\002 \001(\001\022"
+    "\023\n\013ymeasureMin\030\003 \001(\001\022\023\n\013ymeasureMax\030\004 \001("
+    "\001\022\017\n\007xposfix\030\005 \001(\001\022\017\n\007yposfix\030\006 \001(\001\022\021\n\ts"
+    "canAngle\030\007 \001(\001\022\024\n\014scanAngleMin\030\010 \001(\001\022\024\n\014"
+    "scanAngleMax\030\t \001(\001\022\020\n\010fixAngle\030\n \001(\001\022\023\n\013"
+    "fixAngleMin\030\013 \001(\001\022\023\n\013fixAngleMax\030\014 \001(\001\022\020"
+    "\n\010xcorrect\030\r \001(\001\022\020\n\010ycorrect\030\016 \001(\001\022\023\n\013xc"
+    "orrectMin\030\017 \001(\001\022\023\n\013xcorrectMax\030\020 \001(\001\022\023\n\013"
+    "ycorrectMin\030\021 \001(\001\022\023\n\013ycorrectMax\030\022 \001(\001\022\023"
+    "\n\013realXOffset\030\023 \001(\001\022\023\n\013realYOffset\030\024 \001(\001"
+    "\022\017\n\007factorK\030\025 \001(\001\022\027\n\017isCorrectFile3D\030\026 \001"
+    "(\010\022\026\n\016isDynamicFocus\030\027 \001(\010\022\024\n\014defocusRat"
+    "io\030\030 \001(\001\022\027\n\017defocusRatioMin\030\031 \001(\001\022\027\n\017def"
+    "ocusRatioMax\030\032 \001(\001\"\226\004\n\013ScanTestCfg\022\022\n\nde"
+    "bugShape\030\001 \001(\005\022\021\n\tshapeSize\030\002 \001(\005\022\024\n\014sha"
+    "peSizeMin\030\003 \001(\005\022\026\n\016shape_size_max\030\004 \001(\005\022"
+    "\023\n\013laser_power\030\005 \001(\005\022\027\n\017laser_power_min\030"
+    "\006 \001(\005\022\027\n\017laser_power_max\030\007 \001(\005\022\017\n\007defocu"
+    "s\030\010 \001(\001\022\023\n\013defocus_min\030\t \001(\001\022\023\n\013defocus_"
+    "max\030\n \001(\001\022\020\n\010is_cycle\030\013 \001(\010\022\017\n\007cross_x\030\014"
+    " \001(\001\022\017\n\007cross_y\030\r \001(\001\022\022\n\nz_distance\030\016 \001("
+    "\001\022\034\n\024isAutoHeatingScanner\030\017 \001(\010\022!\n\031autoH"
+    "eatingScannerMinutes\030\020 \001(\r\022\036\n\026autoHeatin"
+    "gScannerSize\030\021 \001(\r\022\037\n\027autoHeatingScanner"
+    "Speed\030\022 \001(\001\022\031\n\021mark_test_start_x\030\023 \001(\001\022\031"
+    "\n\021mark_test_start_y\030\024 \001(\001\022\027\n\017mark_test_e"
+    "nd_x\030\025 \001(\001\022\027\n\017mark_test_end_y\030\026 \001(\001\"\314\002\n\r"
+    "SkyWritingCfg\022\020\n\010isEnable\030\001 \001(\010\022\017\n\007timel"
+    "ag\030\002 \001(\001\022\022\n\ntimelagMin\030\003 \001(\001\022\022\n\ntimelagM"
+    "ax\030\004 \001(\001\022\024\n\014laserOnShift\030\005 \001(\003\022\027\n\017laserO"
+    "nShiftMin\030\006 \001(\003\022\027\n\017laserOnShiftMax\030\007 \001(\003"
+    "\022\r\n\005nprev\030\010 \001(\r\022\020\n\010nprevMin\030\t \001(\r\022\020\n\010npr"
+    "evMax\030\n \001(\r\022\r\n\005npost\030\013 \001(\r\022\020\n\010npostMin\030\014"
+    " \001(\r\022\020\n\010npostMax\030\r \001(\r\022\014\n\004mode\030\016 \001(\005\022\016\n\006"
+    "limite\030\017 \001(\001\022\021\n\tlimiteMin\030\020 \001(\001\022\021\n\tlimit"
+    "eMax\030\021 \001(\001\"d\n\017PowerCompensate\022\013\n\003cno\030\001 \001"
+    "(\005\022\017\n\007percent\030\002 \001(\005\022\r\n\005value\030\003 \001(\002\022\021\n\tva"
+    "lue_min\030\004 \001(\002\022\021\n\tvalue_max\030\005 \001(\002\"j\n\023Time"
+    "PowerCompensate\022\n\n\002id\030\001 \001(\005\022\013\n\003cno\030\002 \001(\005"
+    "\022\023\n\013startMinute\030\003 \001(\r\022\021\n\tendMinute\030\004 \001(\r"
+    "\022\022\n\ncompensate\030\005 \001(\002*\223\001\n\004TYPE\022\t\n\005iBOOL\020\000"
+    "\022\n\n\006iSHORT\020\001\022\013\n\007iUSHORT\020\002\022\010\n\004iINT\020\003\022\t\n\005i"
+    "UINT\020\004\022\n\n\006iFLOAT\020\005\022\013\n\007iSTRING\020\006\022\t\n\005iCHAR"
+    "\020\007\022\n\n\006iUCHAR\020\010\022\t\n\005iWORD\020\t\022\013\n\007iDOUBLE\020\n\022\n"
+    "\n\006iTIMET\020\013**\n\nDATAHANDLE\022\n\n\006UPDATE\020\000\022\007\n\003"
+    "ADD\020\001\022\007\n\003DEL\020\0022\372\001\n\006Stream\0224\n\006Simple\022\023.st"
+    "ream.RequestInfo\032\023.stream.ResponseAny\"\000\022"
+    "=\n\014ServerStream\022\023.stream.RequestInfo\032\024.s"
+    "tream.ResponseInfo\"\0000\001\022=\n\014ClientStream\022\023"
+    ".stream.RequestInfo\032\024.stream.ResponseInf"
+    "o\"\000(\001\022<\n\tAllStream\022\023.stream.RequestInfo\032"
+    "\024.stream.ResponseInfo\"\000(\0010\001B-\n\027io.grpc.e"
+    "xamples.streamB\013StreamProtoP\001\242\002\002STb\006prot"
+    "o3"
 };
 static const ::_pbi::DescriptorTable* const descriptor_table_stream_2eproto_deps[1] =
     {
@@ -497,13 +1113,13 @@ static ::absl::once_flag descriptor_table_stream_2eproto_once;
 const ::_pbi::DescriptorTable descriptor_table_stream_2eproto = {
     false,
     false,
-    1699,
+    5002,
     descriptor_table_protodef_stream_2eproto,
     "stream.proto",
     &descriptor_table_stream_2eproto_once,
     descriptor_table_stream_2eproto_deps,
     1,
-    12,
+    21,
     schemas,
     file_default_instances,
     TableStruct_stream_2eproto::offsets,
@@ -585,13 +1201,21 @@ ParamInfo::ParamInfo(const ParamInfo& from) : ::google::protobuf::Message() {
       decltype(_impl_.namekey_){},
       decltype(_impl_.strvalue_){},
       decltype(_impl_.context_){},
+      decltype(_impl_.cardname_){},
+      decltype(_impl_.cardip_){},
       decltype(_impl_.valuetype_){},
+      decltype(_impl_.startlayer_){},
       decltype(_impl_.isenable_){},
       decltype(_impl_.isalarm_){},
       decltype(_impl_.isshow_){},
-      decltype(_impl_.startlayer_){},
+      decltype(_impl_.hadassign_){},
       decltype(_impl_.endlayer_){},
       decltype(_impl_.powder_){},
+      decltype(_impl_.seqno_){},
+      decltype(_impl_.controlno_){},
+      decltype(_impl_.serialno_){},
+      decltype(_impl_.controltype_){},
+      decltype(_impl_.hadmatch_){},
       /*decltype(_impl_._cached_size_)*/ {},
   };
   _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
@@ -617,9 +1241,23 @@ ParamInfo::ParamInfo(const ParamInfo& from) : ::google::protobuf::Message() {
   if (!from._internal_context().empty()) {
     _this->_impl_.context_.Set(from._internal_context(), _this->GetArenaForAllocation());
   }
+  _impl_.cardname_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        _impl_.cardname_.Set("", GetArenaForAllocation());
+  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (!from._internal_cardname().empty()) {
+    _this->_impl_.cardname_.Set(from._internal_cardname(), _this->GetArenaForAllocation());
+  }
+  _impl_.cardip_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        _impl_.cardip_.Set("", GetArenaForAllocation());
+  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (!from._internal_cardip().empty()) {
+    _this->_impl_.cardip_.Set(from._internal_cardip(), _this->GetArenaForAllocation());
+  }
   ::memcpy(&_impl_.valuetype_, &from._impl_.valuetype_,
-    static_cast<::size_t>(reinterpret_cast<char*>(&_impl_.powder_) -
-    reinterpret_cast<char*>(&_impl_.valuetype_)) + sizeof(_impl_.powder_));
+    static_cast<::size_t>(reinterpret_cast<char*>(&_impl_.hadmatch_) -
+    reinterpret_cast<char*>(&_impl_.valuetype_)) + sizeof(_impl_.hadmatch_));
 
   // @@protoc_insertion_point(copy_constructor:stream.ParamInfo)
 }
@@ -629,13 +1267,21 @@ inline void ParamInfo::SharedCtor(::_pb::Arena* arena) {
       decltype(_impl_.namekey_){},
       decltype(_impl_.strvalue_){},
       decltype(_impl_.context_){},
+      decltype(_impl_.cardname_){},
+      decltype(_impl_.cardip_){},
       decltype(_impl_.valuetype_){0},
+      decltype(_impl_.startlayer_){0},
       decltype(_impl_.isenable_){false},
       decltype(_impl_.isalarm_){false},
       decltype(_impl_.isshow_){false},
-      decltype(_impl_.startlayer_){0},
+      decltype(_impl_.hadassign_){false},
       decltype(_impl_.endlayer_){0},
       decltype(_impl_.powder_){0},
+      decltype(_impl_.seqno_){0},
+      decltype(_impl_.controlno_){0},
+      decltype(_impl_.serialno_){0},
+      decltype(_impl_.controltype_){0},
+      decltype(_impl_.hadmatch_){false},
       /*decltype(_impl_._cached_size_)*/ {},
   };
   _impl_.namekey_.InitDefault();
@@ -650,6 +1296,14 @@ inline void ParamInfo::SharedCtor(::_pb::Arena* arena) {
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
         _impl_.context_.Set("", GetArenaForAllocation());
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.cardname_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        _impl_.cardname_.Set("", GetArenaForAllocation());
+  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.cardip_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        _impl_.cardip_.Set("", GetArenaForAllocation());
+  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
 }
 ParamInfo::~ParamInfo() {
   // @@protoc_insertion_point(destructor:stream.ParamInfo)
@@ -661,6 +1315,8 @@ inline void ParamInfo::SharedDtor() {
   _impl_.namekey_.Destroy();
   _impl_.strvalue_.Destroy();
   _impl_.context_.Destroy();
+  _impl_.cardname_.Destroy();
+  _impl_.cardip_.Destroy();
 }
 void ParamInfo::SetCachedSize(int size) const {
   _impl_._cached_size_.Set(size);
@@ -675,9 +1331,11 @@ PROTOBUF_NOINLINE void ParamInfo::Clear() {
   _impl_.namekey_.ClearToEmpty();
   _impl_.strvalue_.ClearToEmpty();
   _impl_.context_.ClearToEmpty();
+  _impl_.cardname_.ClearToEmpty();
+  _impl_.cardip_.ClearToEmpty();
   ::memset(&_impl_.valuetype_, 0, static_cast<::size_t>(
-      reinterpret_cast<char*>(&_impl_.powder_) -
-      reinterpret_cast<char*>(&_impl_.valuetype_)) + sizeof(_impl_.powder_));
+      reinterpret_cast<char*>(&_impl_.hadmatch_) -
+      reinterpret_cast<char*>(&_impl_.valuetype_)) + sizeof(_impl_.hadmatch_));
   _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
 }
 
@@ -689,15 +1347,15 @@ const char* ParamInfo::_InternalParse(
 
 
 PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
-const ::_pbi::TcParseTable<4, 10, 0, 0, 2> ParamInfo::_table_ = {
+const ::_pbi::TcParseTable<5, 18, 0, 0, 2> ParamInfo::_table_ = {
   {
     0,  // no _has_bits_
     0, // no _extensions_
-    10, 120,  // max_field_number, fast_idx_mask
+    18, 248,  // max_field_number, fast_idx_mask
     offsetof(decltype(_table_), field_lookup_table),
-    4294966272,  // skipmap
+    4294705152,  // skipmap
     offsetof(decltype(_table_), field_entries),
-    10,  // num_field_entries
+    18,  // num_field_entries
     0,  // num_aux_entries
     offsetof(decltype(_table_), field_names),  // no aux_entries
     &_ParamInfo_default_instance_._instance,
@@ -734,6 +1392,38 @@ const ::_pbi::TcParseTable<4, 10, 0, 0, 2> ParamInfo::_table_ = {
     // float powder = 10;
     {::_pbi::TcParser::FastF32S1,
      {85, 63, 0, PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.powder_)}},
+    // int32 seqNo = 11;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ParamInfo, _impl_.seqno_), 63>(),
+     {88, 63, 0, PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.seqno_)}},
+    // int32 controlNo = 12;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ParamInfo, _impl_.controlno_), 63>(),
+     {96, 63, 0, PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.controlno_)}},
+    // int32 serialNo = 13;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ParamInfo, _impl_.serialno_), 63>(),
+     {104, 63, 0, PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.serialno_)}},
+    // int32 controlType = 14;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ParamInfo, _impl_.controltype_), 63>(),
+     {112, 63, 0, PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.controltype_)}},
+    // bytes cardName = 15;
+    {::_pbi::TcParser::FastBS1,
+     {122, 63, 0, PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.cardname_)}},
+    // bytes cardIP = 16;
+    {::_pbi::TcParser::FastBS2,
+     {386, 63, 0, PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.cardip_)}},
+    // bool hadAssign = 17;
+    {::_pbi::TcParser::FastV8S2,
+     {392, 63, 0, PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.hadassign_)}},
+    // bool hadMatch = 18;
+    {::_pbi::TcParser::FastV8S2,
+     {400, 63, 0, PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.hadmatch_)}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
     {::_pbi::TcParser::MiniParse, {}},
     {::_pbi::TcParser::MiniParse, {}},
     {::_pbi::TcParser::MiniParse, {}},
@@ -772,6 +1462,30 @@ const ::_pbi::TcParseTable<4, 10, 0, 0, 2> ParamInfo::_table_ = {
     // float powder = 10;
     {PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.powder_), 0, 0,
     (0 | ::_fl::kFcSingular | ::_fl::kFloat)},
+    // int32 seqNo = 11;
+    {PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.seqno_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt32)},
+    // int32 controlNo = 12;
+    {PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.controlno_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt32)},
+    // int32 serialNo = 13;
+    {PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.serialno_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt32)},
+    // int32 controlType = 14;
+    {PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.controltype_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt32)},
+    // bytes cardName = 15;
+    {PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.cardname_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)},
+    // bytes cardIP = 16;
+    {PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.cardip_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)},
+    // bool hadAssign = 17;
+    {PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.hadassign_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kBool)},
+    // bool hadMatch = 18;
+    {PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.hadmatch_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kBool)},
   }},
   // no aux_entries
   {{
@@ -857,6 +1571,60 @@ const ::_pbi::TcParseTable<4, 10, 0, 0, 2> ParamInfo::_table_ = {
         10, this->_internal_powder(), target);
   }
 
+  // int32 seqNo = 11;
+  if (this->_internal_seqno() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt32ToArrayWithField<11>(
+            stream, this->_internal_seqno(), target);
+  }
+
+  // int32 controlNo = 12;
+  if (this->_internal_controlno() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt32ToArrayWithField<12>(
+            stream, this->_internal_controlno(), target);
+  }
+
+  // int32 serialNo = 13;
+  if (this->_internal_serialno() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt32ToArrayWithField<13>(
+            stream, this->_internal_serialno(), target);
+  }
+
+  // int32 controlType = 14;
+  if (this->_internal_controltype() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt32ToArrayWithField<14>(
+            stream, this->_internal_controltype(), target);
+  }
+
+  // bytes cardName = 15;
+  if (!this->_internal_cardname().empty()) {
+    const std::string& _s = this->_internal_cardname();
+    target = stream->WriteBytesMaybeAliased(15, _s, target);
+  }
+
+  // bytes cardIP = 16;
+  if (!this->_internal_cardip().empty()) {
+    const std::string& _s = this->_internal_cardip();
+    target = stream->WriteBytesMaybeAliased(16, _s, target);
+  }
+
+  // bool hadAssign = 17;
+  if (this->_internal_hadassign() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(
+        17, this->_internal_hadassign(), target);
+  }
+
+  // bool hadMatch = 18;
+  if (this->_internal_hadmatch() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(
+        18, this->_internal_hadmatch(), target);
+  }
+
   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
     target =
         ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
@@ -892,12 +1660,30 @@ const ::_pbi::TcParseTable<4, 10, 0, 0, 2> ParamInfo::_table_ = {
                                     this->_internal_context());
   }
 
+  // bytes cardName = 15;
+  if (!this->_internal_cardname().empty()) {
+    total_size += 1 + ::google::protobuf::internal::WireFormatLite::BytesSize(
+                                    this->_internal_cardname());
+  }
+
+  // bytes cardIP = 16;
+  if (!this->_internal_cardip().empty()) {
+    total_size += 2 + ::google::protobuf::internal::WireFormatLite::BytesSize(
+                                    this->_internal_cardip());
+  }
+
   // .stream.TYPE valueType = 3;
   if (this->_internal_valuetype() != 0) {
     total_size += 1 +
                   ::_pbi::WireFormatLite::EnumSize(this->_internal_valuetype());
   }
 
+  // int32 startLayer = 8;
+  if (this->_internal_startlayer() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
+        this->_internal_startlayer());
+  }
+
   // bool isEnable = 5;
   if (this->_internal_isenable() != 0) {
     total_size += 2;
@@ -913,10 +1699,9 @@ const ::_pbi::TcParseTable<4, 10, 0, 0, 2> ParamInfo::_table_ = {
     total_size += 2;
   }
 
-  // int32 startLayer = 8;
-  if (this->_internal_startlayer() != 0) {
-    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
-        this->_internal_startlayer());
+  // bool hadAssign = 17;
+  if (this->_internal_hadassign() != 0) {
+    total_size += 3;
   }
 
   // int32 endLayer = 9;
@@ -935,6 +1720,35 @@ const ::_pbi::TcParseTable<4, 10, 0, 0, 2> ParamInfo::_table_ = {
     total_size += 5;
   }
 
+  // int32 seqNo = 11;
+  if (this->_internal_seqno() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
+        this->_internal_seqno());
+  }
+
+  // int32 controlNo = 12;
+  if (this->_internal_controlno() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
+        this->_internal_controlno());
+  }
+
+  // int32 serialNo = 13;
+  if (this->_internal_serialno() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
+        this->_internal_serialno());
+  }
+
+  // int32 controlType = 14;
+  if (this->_internal_controltype() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
+        this->_internal_controltype());
+  }
+
+  // bool hadMatch = 18;
+  if (this->_internal_hadmatch() != 0) {
+    total_size += 3;
+  }
+
   return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
 }
 
@@ -962,9 +1776,18 @@ void ParamInfo::MergeImpl(::google::protobuf::Message& to_msg, const ::google::p
   if (!from._internal_context().empty()) {
     _this->_internal_set_context(from._internal_context());
   }
+  if (!from._internal_cardname().empty()) {
+    _this->_internal_set_cardname(from._internal_cardname());
+  }
+  if (!from._internal_cardip().empty()) {
+    _this->_internal_set_cardip(from._internal_cardip());
+  }
   if (from._internal_valuetype() != 0) {
     _this->_internal_set_valuetype(from._internal_valuetype());
   }
+  if (from._internal_startlayer() != 0) {
+    _this->_internal_set_startlayer(from._internal_startlayer());
+  }
   if (from._internal_isenable() != 0) {
     _this->_internal_set_isenable(from._internal_isenable());
   }
@@ -974,8 +1797,8 @@ void ParamInfo::MergeImpl(::google::protobuf::Message& to_msg, const ::google::p
   if (from._internal_isshow() != 0) {
     _this->_internal_set_isshow(from._internal_isshow());
   }
-  if (from._internal_startlayer() != 0) {
-    _this->_internal_set_startlayer(from._internal_startlayer());
+  if (from._internal_hadassign() != 0) {
+    _this->_internal_set_hadassign(from._internal_hadassign());
   }
   if (from._internal_endlayer() != 0) {
     _this->_internal_set_endlayer(from._internal_endlayer());
@@ -988,6 +1811,21 @@ void ParamInfo::MergeImpl(::google::protobuf::Message& to_msg, const ::google::p
   if (raw_powder != 0) {
     _this->_internal_set_powder(from._internal_powder());
   }
+  if (from._internal_seqno() != 0) {
+    _this->_internal_set_seqno(from._internal_seqno());
+  }
+  if (from._internal_controlno() != 0) {
+    _this->_internal_set_controlno(from._internal_controlno());
+  }
+  if (from._internal_serialno() != 0) {
+    _this->_internal_set_serialno(from._internal_serialno());
+  }
+  if (from._internal_controltype() != 0) {
+    _this->_internal_set_controltype(from._internal_controltype());
+  }
+  if (from._internal_hadmatch() != 0) {
+    _this->_internal_set_hadmatch(from._internal_hadmatch());
+  }
   _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_);
 }
 
@@ -1013,9 +1851,13 @@ void ParamInfo::InternalSwap(ParamInfo* other) {
                                        &other->_impl_.strvalue_, rhs_arena);
   ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.context_, lhs_arena,
                                        &other->_impl_.context_, rhs_arena);
+  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.cardname_, lhs_arena,
+                                       &other->_impl_.cardname_, rhs_arena);
+  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.cardip_, lhs_arena,
+                                       &other->_impl_.cardip_, rhs_arena);
   ::google::protobuf::internal::memswap<
-      PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.powder_)
-      + sizeof(ParamInfo::_impl_.powder_)
+      PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.hadmatch_)
+      + sizeof(ParamInfo::_impl_.hadmatch_)
       - PROTOBUF_FIELD_OFFSET(ParamInfo, _impl_.valuetype_)>(
           reinterpret_cast<char*>(&_impl_.valuetype_),
           reinterpret_cast<char*>(&other->_impl_.valuetype_));
@@ -3722,6 +4564,5342 @@ void ComResponce::InternalSwap(ComResponce* other) {
       &descriptor_table_stream_2eproto_getter, &descriptor_table_stream_2eproto_once,
       file_level_metadata_stream_2eproto[11]);
 }
+// ===================================================================
+
+class ScannerCrtlCfgResp::_Internal {
+ public:
+};
+
+ScannerCrtlCfgResp::ScannerCrtlCfgResp(::google::protobuf::Arena* arena)
+    : ::google::protobuf::Message(arena) {
+  SharedCtor(arena);
+  // @@protoc_insertion_point(arena_constructor:stream.ScannerCrtlCfgResp)
+}
+ScannerCrtlCfgResp::ScannerCrtlCfgResp(const ScannerCrtlCfgResp& from) : ::google::protobuf::Message() {
+  ScannerCrtlCfgResp* const _this = this;
+  (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_.scannercfg_){from._impl_.scannercfg_},
+      /*decltype(_impl_._cached_size_)*/ {},
+  };
+  _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
+      from._internal_metadata_);
+
+  // @@protoc_insertion_point(copy_constructor:stream.ScannerCrtlCfgResp)
+}
+inline void ScannerCrtlCfgResp::SharedCtor(::_pb::Arena* arena) {
+  (void)arena;
+  new (&_impl_) Impl_{
+      decltype(_impl_.scannercfg_){arena},
+      /*decltype(_impl_._cached_size_)*/ {},
+  };
+}
+ScannerCrtlCfgResp::~ScannerCrtlCfgResp() {
+  // @@protoc_insertion_point(destructor:stream.ScannerCrtlCfgResp)
+  _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
+  SharedDtor();
+}
+inline void ScannerCrtlCfgResp::SharedDtor() {
+  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.scannercfg_.~RepeatedPtrField();
+}
+void ScannerCrtlCfgResp::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+PROTOBUF_NOINLINE void ScannerCrtlCfgResp::Clear() {
+// @@protoc_insertion_point(message_clear_start:stream.ScannerCrtlCfgResp)
+  ::uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _internal_mutable_scannercfg()->Clear();
+  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
+}
+
+const char* ScannerCrtlCfgResp::_InternalParse(
+    const char* ptr, ::_pbi::ParseContext* ctx) {
+  ptr = ::_pbi::TcParser::ParseLoop(this, ptr, ctx, &_table_.header);
+  return ptr;
+}
+
+
+PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
+const ::_pbi::TcParseTable<0, 1, 1, 0, 2> ScannerCrtlCfgResp::_table_ = {
+  {
+    0,  // no _has_bits_
+    0, // no _extensions_
+    1, 0,  // max_field_number, fast_idx_mask
+    offsetof(decltype(_table_), field_lookup_table),
+    4294967294,  // skipmap
+    offsetof(decltype(_table_), field_entries),
+    1,  // num_field_entries
+    1,  // num_aux_entries
+    offsetof(decltype(_table_), aux_entries),
+    &_ScannerCrtlCfgResp_default_instance_._instance,
+    ::_pbi::TcParser::GenericFallback,  // fallback
+  }, {{
+    // repeated .stream.ScannerCrtlCfgData scannerCfg = 1;
+    {::_pbi::TcParser::FastMtR1,
+     {10, 63, 0, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgResp, _impl_.scannercfg_)}},
+  }}, {{
+    65535, 65535
+  }}, {{
+    // repeated .stream.ScannerCrtlCfgData scannerCfg = 1;
+    {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgResp, _impl_.scannercfg_), 0, 0,
+    (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)},
+  }}, {{
+    {::_pbi::TcParser::GetTable<::stream::ScannerCrtlCfgData>()},
+  }}, {{
+  }},
+};
+
+::uint8_t* ScannerCrtlCfgResp::_InternalSerialize(
+    ::uint8_t* target,
+    ::google::protobuf::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:stream.ScannerCrtlCfgResp)
+  ::uint32_t cached_has_bits = 0;
+  (void)cached_has_bits;
+
+  // repeated .stream.ScannerCrtlCfgData scannerCfg = 1;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_scannercfg_size()); i < n; i++) {
+    const auto& repfield = this->_internal_scannercfg().Get(i);
+    target = ::google::protobuf::internal::WireFormatLite::
+        InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target =
+        ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
+            _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:stream.ScannerCrtlCfgResp)
+  return target;
+}
+
+::size_t ScannerCrtlCfgResp::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:stream.ScannerCrtlCfgResp)
+  ::size_t total_size = 0;
+
+  ::uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .stream.ScannerCrtlCfgData scannerCfg = 1;
+  total_size += 1UL * this->_internal_scannercfg_size();
+  for (const auto& msg : this->_internal_scannercfg()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSize(msg);
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::google::protobuf::Message::ClassData ScannerCrtlCfgResp::_class_data_ = {
+    ::google::protobuf::Message::CopyWithSourceCheck,
+    ScannerCrtlCfgResp::MergeImpl
+};
+const ::google::protobuf::Message::ClassData*ScannerCrtlCfgResp::GetClassData() const { return &_class_data_; }
+
+
+void ScannerCrtlCfgResp::MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg) {
+  auto* const _this = static_cast<ScannerCrtlCfgResp*>(&to_msg);
+  auto& from = static_cast<const ScannerCrtlCfgResp&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:stream.ScannerCrtlCfgResp)
+  ABSL_DCHECK_NE(&from, _this);
+  ::uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_internal_mutable_scannercfg()->MergeFrom(from._internal_scannercfg());
+  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ScannerCrtlCfgResp::CopyFrom(const ScannerCrtlCfgResp& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:stream.ScannerCrtlCfgResp)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+PROTOBUF_NOINLINE bool ScannerCrtlCfgResp::IsInitialized() const {
+  return true;
+}
+
+void ScannerCrtlCfgResp::InternalSwap(ScannerCrtlCfgResp* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  _impl_.scannercfg_.InternalSwap(&other->_impl_.scannercfg_);
+}
+
+::google::protobuf::Metadata ScannerCrtlCfgResp::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_stream_2eproto_getter, &descriptor_table_stream_2eproto_once,
+      file_level_metadata_stream_2eproto[12]);
+}
+// ===================================================================
+
+class ScannerCrtlCfgData::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ScannerCrtlCfgData>()._impl_._has_bits_);
+  static constexpr ::int32_t kHasBitsOffset =
+    8 * PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_._has_bits_);
+  static const ::stream::ScanParamCfg& scanparamcfg(const ScannerCrtlCfgData* msg);
+  static void set_has_scanparamcfg(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static const ::stream::ScanParamCfg& hatchingparams(const ScannerCrtlCfgData* msg);
+  static void set_has_hatchingparams(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static const ::stream::ScanParamCfg& borderparams(const ScannerCrtlCfgData* msg);
+  static void set_has_borderparams(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static const ::stream::ScanParamCfg& supportparams(const ScannerCrtlCfgData* msg);
+  static void set_has_supportparams(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static const ::stream::CorrectParamCfg& correctparamcfg(const ScannerCrtlCfgData* msg);
+  static void set_has_correctparamcfg(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static const ::stream::ScanTestCfg& scantestcfg(const ScannerCrtlCfgData* msg);
+  static void set_has_scantestcfg(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
+  static const ::stream::SkyWritingCfg& skywritingcfg(const ScannerCrtlCfgData* msg);
+  static void set_has_skywritingcfg(HasBits* has_bits) {
+    (*has_bits)[0] |= 64u;
+  }
+};
+
+const ::stream::ScanParamCfg& ScannerCrtlCfgData::_Internal::scanparamcfg(const ScannerCrtlCfgData* msg) {
+  return *msg->_impl_.scanparamcfg_;
+}
+const ::stream::ScanParamCfg& ScannerCrtlCfgData::_Internal::hatchingparams(const ScannerCrtlCfgData* msg) {
+  return *msg->_impl_.hatchingparams_;
+}
+const ::stream::ScanParamCfg& ScannerCrtlCfgData::_Internal::borderparams(const ScannerCrtlCfgData* msg) {
+  return *msg->_impl_.borderparams_;
+}
+const ::stream::ScanParamCfg& ScannerCrtlCfgData::_Internal::supportparams(const ScannerCrtlCfgData* msg) {
+  return *msg->_impl_.supportparams_;
+}
+const ::stream::CorrectParamCfg& ScannerCrtlCfgData::_Internal::correctparamcfg(const ScannerCrtlCfgData* msg) {
+  return *msg->_impl_.correctparamcfg_;
+}
+const ::stream::ScanTestCfg& ScannerCrtlCfgData::_Internal::scantestcfg(const ScannerCrtlCfgData* msg) {
+  return *msg->_impl_.scantestcfg_;
+}
+const ::stream::SkyWritingCfg& ScannerCrtlCfgData::_Internal::skywritingcfg(const ScannerCrtlCfgData* msg) {
+  return *msg->_impl_.skywritingcfg_;
+}
+ScannerCrtlCfgData::ScannerCrtlCfgData(::google::protobuf::Arena* arena)
+    : ::google::protobuf::Message(arena) {
+  SharedCtor(arena);
+  // @@protoc_insertion_point(arena_constructor:stream.ScannerCrtlCfgData)
+}
+ScannerCrtlCfgData::ScannerCrtlCfgData(const ScannerCrtlCfgData& from) : ::google::protobuf::Message() {
+  ScannerCrtlCfgData* const _this = this;
+  (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_},
+      /*decltype(_impl_._cached_size_)*/ {},
+      decltype(_impl_.fixpointdata_){from._impl_.fixpointdata_},
+      decltype(_impl_.powercompensate_){from._impl_.powercompensate_},
+      decltype(_impl_.tpowercompensate_){from._impl_.tpowercompensate_},
+      decltype(_impl_.cardname_){},
+      decltype(_impl_.cardip_){},
+      decltype(_impl_.scanparamcfg_){nullptr},
+      decltype(_impl_.hatchingparams_){nullptr},
+      decltype(_impl_.borderparams_){nullptr},
+      decltype(_impl_.supportparams_){nullptr},
+      decltype(_impl_.correctparamcfg_){nullptr},
+      decltype(_impl_.scantestcfg_){nullptr},
+      decltype(_impl_.skywritingcfg_){nullptr},
+      decltype(_impl_.seqno_){},
+      decltype(_impl_.controlno_){},
+      decltype(_impl_.serialno_){},
+      decltype(_impl_.controltype_){},
+      decltype(_impl_.isenable_){},
+      decltype(_impl_.hadassign_){},
+      decltype(_impl_.hadmatch_){},
+  };
+  _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
+      from._internal_metadata_);
+  _impl_.cardname_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        _impl_.cardname_.Set("", GetArenaForAllocation());
+  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (!from._internal_cardname().empty()) {
+    _this->_impl_.cardname_.Set(from._internal_cardname(), _this->GetArenaForAllocation());
+  }
+  _impl_.cardip_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        _impl_.cardip_.Set("", GetArenaForAllocation());
+  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (!from._internal_cardip().empty()) {
+    _this->_impl_.cardip_.Set(from._internal_cardip(), _this->GetArenaForAllocation());
+  }
+  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
+    _this->_impl_.scanparamcfg_ = new ::stream::ScanParamCfg(*from._impl_.scanparamcfg_);
+  }
+  if ((from._impl_._has_bits_[0] & 0x00000002u) != 0) {
+    _this->_impl_.hatchingparams_ = new ::stream::ScanParamCfg(*from._impl_.hatchingparams_);
+  }
+  if ((from._impl_._has_bits_[0] & 0x00000004u) != 0) {
+    _this->_impl_.borderparams_ = new ::stream::ScanParamCfg(*from._impl_.borderparams_);
+  }
+  if ((from._impl_._has_bits_[0] & 0x00000008u) != 0) {
+    _this->_impl_.supportparams_ = new ::stream::ScanParamCfg(*from._impl_.supportparams_);
+  }
+  if ((from._impl_._has_bits_[0] & 0x00000010u) != 0) {
+    _this->_impl_.correctparamcfg_ = new ::stream::CorrectParamCfg(*from._impl_.correctparamcfg_);
+  }
+  if ((from._impl_._has_bits_[0] & 0x00000020u) != 0) {
+    _this->_impl_.scantestcfg_ = new ::stream::ScanTestCfg(*from._impl_.scantestcfg_);
+  }
+  if ((from._impl_._has_bits_[0] & 0x00000040u) != 0) {
+    _this->_impl_.skywritingcfg_ = new ::stream::SkyWritingCfg(*from._impl_.skywritingcfg_);
+  }
+  ::memcpy(&_impl_.seqno_, &from._impl_.seqno_,
+    static_cast<::size_t>(reinterpret_cast<char*>(&_impl_.hadmatch_) -
+    reinterpret_cast<char*>(&_impl_.seqno_)) + sizeof(_impl_.hadmatch_));
+
+  // @@protoc_insertion_point(copy_constructor:stream.ScannerCrtlCfgData)
+}
+inline void ScannerCrtlCfgData::SharedCtor(::_pb::Arena* arena) {
+  (void)arena;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){},
+      /*decltype(_impl_._cached_size_)*/ {},
+      decltype(_impl_.fixpointdata_){arena},
+      decltype(_impl_.powercompensate_){arena},
+      decltype(_impl_.tpowercompensate_){arena},
+      decltype(_impl_.cardname_){},
+      decltype(_impl_.cardip_){},
+      decltype(_impl_.scanparamcfg_){nullptr},
+      decltype(_impl_.hatchingparams_){nullptr},
+      decltype(_impl_.borderparams_){nullptr},
+      decltype(_impl_.supportparams_){nullptr},
+      decltype(_impl_.correctparamcfg_){nullptr},
+      decltype(_impl_.scantestcfg_){nullptr},
+      decltype(_impl_.skywritingcfg_){nullptr},
+      decltype(_impl_.seqno_){0},
+      decltype(_impl_.controlno_){0},
+      decltype(_impl_.serialno_){0},
+      decltype(_impl_.controltype_){0},
+      decltype(_impl_.isenable_){false},
+      decltype(_impl_.hadassign_){false},
+      decltype(_impl_.hadmatch_){false},
+  };
+  _impl_.cardname_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        _impl_.cardname_.Set("", GetArenaForAllocation());
+  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.cardip_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        _impl_.cardip_.Set("", GetArenaForAllocation());
+  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+ScannerCrtlCfgData::~ScannerCrtlCfgData() {
+  // @@protoc_insertion_point(destructor:stream.ScannerCrtlCfgData)
+  _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
+  SharedDtor();
+}
+inline void ScannerCrtlCfgData::SharedDtor() {
+  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.fixpointdata_.~RepeatedPtrField();
+  _impl_.powercompensate_.~RepeatedPtrField();
+  _impl_.tpowercompensate_.~RepeatedPtrField();
+  _impl_.cardname_.Destroy();
+  _impl_.cardip_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.scanparamcfg_;
+  if (this != internal_default_instance()) delete _impl_.hatchingparams_;
+  if (this != internal_default_instance()) delete _impl_.borderparams_;
+  if (this != internal_default_instance()) delete _impl_.supportparams_;
+  if (this != internal_default_instance()) delete _impl_.correctparamcfg_;
+  if (this != internal_default_instance()) delete _impl_.scantestcfg_;
+  if (this != internal_default_instance()) delete _impl_.skywritingcfg_;
+}
+void ScannerCrtlCfgData::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+PROTOBUF_NOINLINE void ScannerCrtlCfgData::Clear() {
+// @@protoc_insertion_point(message_clear_start:stream.ScannerCrtlCfgData)
+  ::uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _internal_mutable_fixpointdata()->Clear();
+  _internal_mutable_powercompensate()->Clear();
+  _internal_mutable_tpowercompensate()->Clear();
+  _impl_.cardname_.ClearToEmpty();
+  _impl_.cardip_.ClearToEmpty();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000007fu) {
+    if (cached_has_bits & 0x00000001u) {
+      ABSL_DCHECK(_impl_.scanparamcfg_ != nullptr);
+      _impl_.scanparamcfg_->Clear();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      ABSL_DCHECK(_impl_.hatchingparams_ != nullptr);
+      _impl_.hatchingparams_->Clear();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      ABSL_DCHECK(_impl_.borderparams_ != nullptr);
+      _impl_.borderparams_->Clear();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      ABSL_DCHECK(_impl_.supportparams_ != nullptr);
+      _impl_.supportparams_->Clear();
+    }
+    if (cached_has_bits & 0x00000010u) {
+      ABSL_DCHECK(_impl_.correctparamcfg_ != nullptr);
+      _impl_.correctparamcfg_->Clear();
+    }
+    if (cached_has_bits & 0x00000020u) {
+      ABSL_DCHECK(_impl_.scantestcfg_ != nullptr);
+      _impl_.scantestcfg_->Clear();
+    }
+    if (cached_has_bits & 0x00000040u) {
+      ABSL_DCHECK(_impl_.skywritingcfg_ != nullptr);
+      _impl_.skywritingcfg_->Clear();
+    }
+  }
+  ::memset(&_impl_.seqno_, 0, static_cast<::size_t>(
+      reinterpret_cast<char*>(&_impl_.hadmatch_) -
+      reinterpret_cast<char*>(&_impl_.seqno_)) + sizeof(_impl_.hadmatch_));
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
+}
+
+const char* ScannerCrtlCfgData::_InternalParse(
+    const char* ptr, ::_pbi::ParseContext* ctx) {
+  ptr = ::_pbi::TcParser::ParseLoop(this, ptr, ctx, &_table_.header);
+  return ptr;
+}
+
+
+PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
+const ::_pbi::TcParseTable<5, 19, 10, 0, 2> ScannerCrtlCfgData::_table_ = {
+  {
+    PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_._has_bits_),
+    0, // no _extensions_
+    19, 248,  // max_field_number, fast_idx_mask
+    offsetof(decltype(_table_), field_lookup_table),
+    4294443008,  // skipmap
+    offsetof(decltype(_table_), field_entries),
+    19,  // num_field_entries
+    10,  // num_aux_entries
+    offsetof(decltype(_table_), aux_entries),
+    &_ScannerCrtlCfgData_default_instance_._instance,
+    ::_pbi::TcParser::GenericFallback,  // fallback
+  }, {{
+    {::_pbi::TcParser::MiniParse, {}},
+    // int32 seqNo = 1;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScannerCrtlCfgData, _impl_.seqno_), 63>(),
+     {8, 63, 0, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.seqno_)}},
+    // repeated .stream.FixPointData fixPointData = 2;
+    {::_pbi::TcParser::FastMtR1,
+     {18, 63, 0, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.fixpointdata_)}},
+    // .stream.ScanParamCfg scanParamCfg = 3;
+    {::_pbi::TcParser::FastMtS1,
+     {26, 0, 1, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.scanparamcfg_)}},
+    // .stream.ScanParamCfg hatchingParams = 4;
+    {::_pbi::TcParser::FastMtS1,
+     {34, 1, 2, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.hatchingparams_)}},
+    // .stream.ScanParamCfg borderParams = 5;
+    {::_pbi::TcParser::FastMtS1,
+     {42, 2, 3, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.borderparams_)}},
+    // .stream.ScanParamCfg supportParams = 6;
+    {::_pbi::TcParser::FastMtS1,
+     {50, 3, 4, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.supportparams_)}},
+    // .stream.CorrectParamCfg correctParamCfg = 7;
+    {::_pbi::TcParser::FastMtS1,
+     {58, 4, 5, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.correctparamcfg_)}},
+    // .stream.ScanTestCfg scanTestCfg = 8;
+    {::_pbi::TcParser::FastMtS1,
+     {66, 5, 6, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.scantestcfg_)}},
+    // .stream.SkyWritingCfg skyWritingCfg = 9;
+    {::_pbi::TcParser::FastMtS1,
+     {74, 6, 7, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.skywritingcfg_)}},
+    // repeated .stream.PowerCompensate powerCompensate = 10;
+    {::_pbi::TcParser::FastMtR1,
+     {82, 63, 8, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.powercompensate_)}},
+    // repeated .stream.TimePowerCompensate tPowerCompensate = 11;
+    {::_pbi::TcParser::FastMtR1,
+     {90, 63, 9, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.tpowercompensate_)}},
+    // int32 controlNo = 12;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScannerCrtlCfgData, _impl_.controlno_), 63>(),
+     {96, 63, 0, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.controlno_)}},
+    // int32 serialNo = 13;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScannerCrtlCfgData, _impl_.serialno_), 63>(),
+     {104, 63, 0, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.serialno_)}},
+    // int32 controlType = 14;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScannerCrtlCfgData, _impl_.controltype_), 63>(),
+     {112, 63, 0, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.controltype_)}},
+    // bytes cardName = 15;
+    {::_pbi::TcParser::FastBS1,
+     {122, 63, 0, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.cardname_)}},
+    // bytes cardIP = 16;
+    {::_pbi::TcParser::FastBS2,
+     {386, 63, 0, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.cardip_)}},
+    // bool isEnable = 17;
+    {::_pbi::TcParser::FastV8S2,
+     {392, 63, 0, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.isenable_)}},
+    // bool hadAssign = 18;
+    {::_pbi::TcParser::FastV8S2,
+     {400, 63, 0, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.hadassign_)}},
+    // bool hadMatch = 19;
+    {::_pbi::TcParser::FastV8S2,
+     {408, 63, 0, PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.hadmatch_)}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+  }}, {{
+    65535, 65535
+  }}, {{
+    // int32 seqNo = 1;
+    {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.seqno_), -1, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt32)},
+    // repeated .stream.FixPointData fixPointData = 2;
+    {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.fixpointdata_), -1, 0,
+    (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)},
+    // .stream.ScanParamCfg scanParamCfg = 3;
+    {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.scanparamcfg_), _Internal::kHasBitsOffset + 0, 1,
+    (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
+    // .stream.ScanParamCfg hatchingParams = 4;
+    {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.hatchingparams_), _Internal::kHasBitsOffset + 1, 2,
+    (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
+    // .stream.ScanParamCfg borderParams = 5;
+    {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.borderparams_), _Internal::kHasBitsOffset + 2, 3,
+    (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
+    // .stream.ScanParamCfg supportParams = 6;
+    {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.supportparams_), _Internal::kHasBitsOffset + 3, 4,
+    (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
+    // .stream.CorrectParamCfg correctParamCfg = 7;
+    {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.correctparamcfg_), _Internal::kHasBitsOffset + 4, 5,
+    (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
+    // .stream.ScanTestCfg scanTestCfg = 8;
+    {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.scantestcfg_), _Internal::kHasBitsOffset + 5, 6,
+    (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
+    // .stream.SkyWritingCfg skyWritingCfg = 9;
+    {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.skywritingcfg_), _Internal::kHasBitsOffset + 6, 7,
+    (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
+    // repeated .stream.PowerCompensate powerCompensate = 10;
+    {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.powercompensate_), -1, 8,
+    (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)},
+    // repeated .stream.TimePowerCompensate tPowerCompensate = 11;
+    {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.tpowercompensate_), -1, 9,
+    (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)},
+    // int32 controlNo = 12;
+    {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.controlno_), -1, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt32)},
+    // int32 serialNo = 13;
+    {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.serialno_), -1, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt32)},
+    // int32 controlType = 14;
+    {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.controltype_), -1, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt32)},
+    // bytes cardName = 15;
+    {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.cardname_), -1, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)},
+    // bytes cardIP = 16;
+    {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.cardip_), -1, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)},
+    // bool isEnable = 17;
+    {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.isenable_), -1, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kBool)},
+    // bool hadAssign = 18;
+    {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.hadassign_), -1, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kBool)},
+    // bool hadMatch = 19;
+    {PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.hadmatch_), -1, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kBool)},
+  }}, {{
+    {::_pbi::TcParser::GetTable<::stream::FixPointData>()},
+    {::_pbi::TcParser::GetTable<::stream::ScanParamCfg>()},
+    {::_pbi::TcParser::GetTable<::stream::ScanParamCfg>()},
+    {::_pbi::TcParser::GetTable<::stream::ScanParamCfg>()},
+    {::_pbi::TcParser::GetTable<::stream::ScanParamCfg>()},
+    {::_pbi::TcParser::GetTable<::stream::CorrectParamCfg>()},
+    {::_pbi::TcParser::GetTable<::stream::ScanTestCfg>()},
+    {::_pbi::TcParser::GetTable<::stream::SkyWritingCfg>()},
+    {::_pbi::TcParser::GetTable<::stream::PowerCompensate>()},
+    {::_pbi::TcParser::GetTable<::stream::TimePowerCompensate>()},
+  }}, {{
+  }},
+};
+
+::uint8_t* ScannerCrtlCfgData::_InternalSerialize(
+    ::uint8_t* target,
+    ::google::protobuf::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:stream.ScannerCrtlCfgData)
+  ::uint32_t cached_has_bits = 0;
+  (void)cached_has_bits;
+
+  // int32 seqNo = 1;
+  if (this->_internal_seqno() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt32ToArrayWithField<1>(
+            stream, this->_internal_seqno(), target);
+  }
+
+  // repeated .stream.FixPointData fixPointData = 2;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_fixpointdata_size()); i < n; i++) {
+    const auto& repfield = this->_internal_fixpointdata().Get(i);
+    target = ::google::protobuf::internal::WireFormatLite::
+        InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // .stream.ScanParamCfg scanParamCfg = 3;
+  if (cached_has_bits & 0x00000001u) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      InternalWriteMessage(3, _Internal::scanparamcfg(this),
+        _Internal::scanparamcfg(this).GetCachedSize(), target, stream);
+  }
+
+  // .stream.ScanParamCfg hatchingParams = 4;
+  if (cached_has_bits & 0x00000002u) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      InternalWriteMessage(4, _Internal::hatchingparams(this),
+        _Internal::hatchingparams(this).GetCachedSize(), target, stream);
+  }
+
+  // .stream.ScanParamCfg borderParams = 5;
+  if (cached_has_bits & 0x00000004u) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      InternalWriteMessage(5, _Internal::borderparams(this),
+        _Internal::borderparams(this).GetCachedSize(), target, stream);
+  }
+
+  // .stream.ScanParamCfg supportParams = 6;
+  if (cached_has_bits & 0x00000008u) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      InternalWriteMessage(6, _Internal::supportparams(this),
+        _Internal::supportparams(this).GetCachedSize(), target, stream);
+  }
+
+  // .stream.CorrectParamCfg correctParamCfg = 7;
+  if (cached_has_bits & 0x00000010u) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      InternalWriteMessage(7, _Internal::correctparamcfg(this),
+        _Internal::correctparamcfg(this).GetCachedSize(), target, stream);
+  }
+
+  // .stream.ScanTestCfg scanTestCfg = 8;
+  if (cached_has_bits & 0x00000020u) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      InternalWriteMessage(8, _Internal::scantestcfg(this),
+        _Internal::scantestcfg(this).GetCachedSize(), target, stream);
+  }
+
+  // .stream.SkyWritingCfg skyWritingCfg = 9;
+  if (cached_has_bits & 0x00000040u) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      InternalWriteMessage(9, _Internal::skywritingcfg(this),
+        _Internal::skywritingcfg(this).GetCachedSize(), target, stream);
+  }
+
+  // repeated .stream.PowerCompensate powerCompensate = 10;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_powercompensate_size()); i < n; i++) {
+    const auto& repfield = this->_internal_powercompensate().Get(i);
+    target = ::google::protobuf::internal::WireFormatLite::
+        InternalWriteMessage(10, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  // repeated .stream.TimePowerCompensate tPowerCompensate = 11;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_tpowercompensate_size()); i < n; i++) {
+    const auto& repfield = this->_internal_tpowercompensate().Get(i);
+    target = ::google::protobuf::internal::WireFormatLite::
+        InternalWriteMessage(11, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  // int32 controlNo = 12;
+  if (this->_internal_controlno() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt32ToArrayWithField<12>(
+            stream, this->_internal_controlno(), target);
+  }
+
+  // int32 serialNo = 13;
+  if (this->_internal_serialno() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt32ToArrayWithField<13>(
+            stream, this->_internal_serialno(), target);
+  }
+
+  // int32 controlType = 14;
+  if (this->_internal_controltype() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt32ToArrayWithField<14>(
+            stream, this->_internal_controltype(), target);
+  }
+
+  // bytes cardName = 15;
+  if (!this->_internal_cardname().empty()) {
+    const std::string& _s = this->_internal_cardname();
+    target = stream->WriteBytesMaybeAliased(15, _s, target);
+  }
+
+  // bytes cardIP = 16;
+  if (!this->_internal_cardip().empty()) {
+    const std::string& _s = this->_internal_cardip();
+    target = stream->WriteBytesMaybeAliased(16, _s, target);
+  }
+
+  // bool isEnable = 17;
+  if (this->_internal_isenable() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(
+        17, this->_internal_isenable(), target);
+  }
+
+  // bool hadAssign = 18;
+  if (this->_internal_hadassign() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(
+        18, this->_internal_hadassign(), target);
+  }
+
+  // bool hadMatch = 19;
+  if (this->_internal_hadmatch() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(
+        19, this->_internal_hadmatch(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target =
+        ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
+            _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:stream.ScannerCrtlCfgData)
+  return target;
+}
+
+::size_t ScannerCrtlCfgData::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:stream.ScannerCrtlCfgData)
+  ::size_t total_size = 0;
+
+  ::uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .stream.FixPointData fixPointData = 2;
+  total_size += 1UL * this->_internal_fixpointdata_size();
+  for (const auto& msg : this->_internal_fixpointdata()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSize(msg);
+  }
+  // repeated .stream.PowerCompensate powerCompensate = 10;
+  total_size += 1UL * this->_internal_powercompensate_size();
+  for (const auto& msg : this->_internal_powercompensate()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSize(msg);
+  }
+  // repeated .stream.TimePowerCompensate tPowerCompensate = 11;
+  total_size += 1UL * this->_internal_tpowercompensate_size();
+  for (const auto& msg : this->_internal_tpowercompensate()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSize(msg);
+  }
+  // bytes cardName = 15;
+  if (!this->_internal_cardname().empty()) {
+    total_size += 1 + ::google::protobuf::internal::WireFormatLite::BytesSize(
+                                    this->_internal_cardname());
+  }
+
+  // bytes cardIP = 16;
+  if (!this->_internal_cardip().empty()) {
+    total_size += 2 + ::google::protobuf::internal::WireFormatLite::BytesSize(
+                                    this->_internal_cardip());
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000007fu) {
+    // .stream.ScanParamCfg scanParamCfg = 3;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSize(
+          *_impl_.scanparamcfg_);
+    }
+
+    // .stream.ScanParamCfg hatchingParams = 4;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSize(
+          *_impl_.hatchingparams_);
+    }
+
+    // .stream.ScanParamCfg borderParams = 5;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSize(
+          *_impl_.borderparams_);
+    }
+
+    // .stream.ScanParamCfg supportParams = 6;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSize(
+          *_impl_.supportparams_);
+    }
+
+    // .stream.CorrectParamCfg correctParamCfg = 7;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSize(
+          *_impl_.correctparamcfg_);
+    }
+
+    // .stream.ScanTestCfg scanTestCfg = 8;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSize(
+          *_impl_.scantestcfg_);
+    }
+
+    // .stream.SkyWritingCfg skyWritingCfg = 9;
+    if (cached_has_bits & 0x00000040u) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSize(
+          *_impl_.skywritingcfg_);
+    }
+
+  }
+  // int32 seqNo = 1;
+  if (this->_internal_seqno() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
+        this->_internal_seqno());
+  }
+
+  // int32 controlNo = 12;
+  if (this->_internal_controlno() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
+        this->_internal_controlno());
+  }
+
+  // int32 serialNo = 13;
+  if (this->_internal_serialno() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
+        this->_internal_serialno());
+  }
+
+  // int32 controlType = 14;
+  if (this->_internal_controltype() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
+        this->_internal_controltype());
+  }
+
+  // bool isEnable = 17;
+  if (this->_internal_isenable() != 0) {
+    total_size += 3;
+  }
+
+  // bool hadAssign = 18;
+  if (this->_internal_hadassign() != 0) {
+    total_size += 3;
+  }
+
+  // bool hadMatch = 19;
+  if (this->_internal_hadmatch() != 0) {
+    total_size += 3;
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::google::protobuf::Message::ClassData ScannerCrtlCfgData::_class_data_ = {
+    ::google::protobuf::Message::CopyWithSourceCheck,
+    ScannerCrtlCfgData::MergeImpl
+};
+const ::google::protobuf::Message::ClassData*ScannerCrtlCfgData::GetClassData() const { return &_class_data_; }
+
+
+void ScannerCrtlCfgData::MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg) {
+  auto* const _this = static_cast<ScannerCrtlCfgData*>(&to_msg);
+  auto& from = static_cast<const ScannerCrtlCfgData&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:stream.ScannerCrtlCfgData)
+  ABSL_DCHECK_NE(&from, _this);
+  ::uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_internal_mutable_fixpointdata()->MergeFrom(from._internal_fixpointdata());
+  _this->_internal_mutable_powercompensate()->MergeFrom(from._internal_powercompensate());
+  _this->_internal_mutable_tpowercompensate()->MergeFrom(from._internal_tpowercompensate());
+  if (!from._internal_cardname().empty()) {
+    _this->_internal_set_cardname(from._internal_cardname());
+  }
+  if (!from._internal_cardip().empty()) {
+    _this->_internal_set_cardip(from._internal_cardip());
+  }
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000007fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_mutable_scanparamcfg()->::stream::ScanParamCfg::MergeFrom(
+          from._internal_scanparamcfg());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_mutable_hatchingparams()->::stream::ScanParamCfg::MergeFrom(
+          from._internal_hatchingparams());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_mutable_borderparams()->::stream::ScanParamCfg::MergeFrom(
+          from._internal_borderparams());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_mutable_supportparams()->::stream::ScanParamCfg::MergeFrom(
+          from._internal_supportparams());
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_internal_mutable_correctparamcfg()->::stream::CorrectParamCfg::MergeFrom(
+          from._internal_correctparamcfg());
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_internal_mutable_scantestcfg()->::stream::ScanTestCfg::MergeFrom(
+          from._internal_scantestcfg());
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _this->_internal_mutable_skywritingcfg()->::stream::SkyWritingCfg::MergeFrom(
+          from._internal_skywritingcfg());
+    }
+  }
+  if (from._internal_seqno() != 0) {
+    _this->_internal_set_seqno(from._internal_seqno());
+  }
+  if (from._internal_controlno() != 0) {
+    _this->_internal_set_controlno(from._internal_controlno());
+  }
+  if (from._internal_serialno() != 0) {
+    _this->_internal_set_serialno(from._internal_serialno());
+  }
+  if (from._internal_controltype() != 0) {
+    _this->_internal_set_controltype(from._internal_controltype());
+  }
+  if (from._internal_isenable() != 0) {
+    _this->_internal_set_isenable(from._internal_isenable());
+  }
+  if (from._internal_hadassign() != 0) {
+    _this->_internal_set_hadassign(from._internal_hadassign());
+  }
+  if (from._internal_hadmatch() != 0) {
+    _this->_internal_set_hadmatch(from._internal_hadmatch());
+  }
+  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ScannerCrtlCfgData::CopyFrom(const ScannerCrtlCfgData& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:stream.ScannerCrtlCfgData)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+PROTOBUF_NOINLINE bool ScannerCrtlCfgData::IsInitialized() const {
+  return true;
+}
+
+void ScannerCrtlCfgData::InternalSwap(ScannerCrtlCfgData* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.fixpointdata_.InternalSwap(&other->_impl_.fixpointdata_);
+  _impl_.powercompensate_.InternalSwap(&other->_impl_.powercompensate_);
+  _impl_.tpowercompensate_.InternalSwap(&other->_impl_.tpowercompensate_);
+  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.cardname_, lhs_arena,
+                                       &other->_impl_.cardname_, rhs_arena);
+  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.cardip_, lhs_arena,
+                                       &other->_impl_.cardip_, rhs_arena);
+  ::google::protobuf::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.hadmatch_)
+      + sizeof(ScannerCrtlCfgData::_impl_.hadmatch_)
+      - PROTOBUF_FIELD_OFFSET(ScannerCrtlCfgData, _impl_.scanparamcfg_)>(
+          reinterpret_cast<char*>(&_impl_.scanparamcfg_),
+          reinterpret_cast<char*>(&other->_impl_.scanparamcfg_));
+}
+
+::google::protobuf::Metadata ScannerCrtlCfgData::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_stream_2eproto_getter, &descriptor_table_stream_2eproto_once,
+      file_level_metadata_stream_2eproto[13]);
+}
+// ===================================================================
+
+class FixPointData::_Internal {
+ public:
+};
+
+FixPointData::FixPointData(::google::protobuf::Arena* arena)
+    : ::google::protobuf::Message(arena) {
+  SharedCtor(arena);
+  // @@protoc_insertion_point(arena_constructor:stream.FixPointData)
+}
+FixPointData::FixPointData(const FixPointData& from)
+    : ::google::protobuf::Message(), _impl_(from._impl_) {
+  _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
+      from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:stream.FixPointData)
+}
+inline void FixPointData::SharedCtor(::_pb::Arena* arena) {
+  (void)arena;
+  new (&_impl_) Impl_{
+      decltype(_impl_.id_){0},
+      decltype(_impl_.cno_){0},
+      decltype(_impl_.pointx_){0},
+      decltype(_impl_.pointy_){0},
+      decltype(_impl_.duration_){0u},
+      /*decltype(_impl_._cached_size_)*/ {},
+  };
+}
+FixPointData::~FixPointData() {
+  // @@protoc_insertion_point(destructor:stream.FixPointData)
+  _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
+  SharedDtor();
+}
+inline void FixPointData::SharedDtor() {
+  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
+}
+void FixPointData::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+PROTOBUF_NOINLINE void FixPointData::Clear() {
+// @@protoc_insertion_point(message_clear_start:stream.FixPointData)
+  ::uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  ::memset(&_impl_.id_, 0, static_cast<::size_t>(
+      reinterpret_cast<char*>(&_impl_.duration_) -
+      reinterpret_cast<char*>(&_impl_.id_)) + sizeof(_impl_.duration_));
+  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
+}
+
+const char* FixPointData::_InternalParse(
+    const char* ptr, ::_pbi::ParseContext* ctx) {
+  ptr = ::_pbi::TcParser::ParseLoop(this, ptr, ctx, &_table_.header);
+  return ptr;
+}
+
+
+PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
+const ::_pbi::TcParseTable<3, 5, 0, 0, 2> FixPointData::_table_ = {
+  {
+    0,  // no _has_bits_
+    0, // no _extensions_
+    5, 56,  // max_field_number, fast_idx_mask
+    offsetof(decltype(_table_), field_lookup_table),
+    4294967264,  // skipmap
+    offsetof(decltype(_table_), field_entries),
+    5,  // num_field_entries
+    0,  // num_aux_entries
+    offsetof(decltype(_table_), field_names),  // no aux_entries
+    &_FixPointData_default_instance_._instance,
+    ::_pbi::TcParser::GenericFallback,  // fallback
+  }, {{
+    {::_pbi::TcParser::MiniParse, {}},
+    // int32 id = 1;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(FixPointData, _impl_.id_), 63>(),
+     {8, 63, 0, PROTOBUF_FIELD_OFFSET(FixPointData, _impl_.id_)}},
+    // int32 cno = 2;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(FixPointData, _impl_.cno_), 63>(),
+     {16, 63, 0, PROTOBUF_FIELD_OFFSET(FixPointData, _impl_.cno_)}},
+    // float pointX = 3;
+    {::_pbi::TcParser::FastF32S1,
+     {29, 63, 0, PROTOBUF_FIELD_OFFSET(FixPointData, _impl_.pointx_)}},
+    // float pointY = 4;
+    {::_pbi::TcParser::FastF32S1,
+     {37, 63, 0, PROTOBUF_FIELD_OFFSET(FixPointData, _impl_.pointy_)}},
+    // uint32 duration = 5;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(FixPointData, _impl_.duration_), 63>(),
+     {40, 63, 0, PROTOBUF_FIELD_OFFSET(FixPointData, _impl_.duration_)}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+  }}, {{
+    65535, 65535
+  }}, {{
+    // int32 id = 1;
+    {PROTOBUF_FIELD_OFFSET(FixPointData, _impl_.id_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt32)},
+    // int32 cno = 2;
+    {PROTOBUF_FIELD_OFFSET(FixPointData, _impl_.cno_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt32)},
+    // float pointX = 3;
+    {PROTOBUF_FIELD_OFFSET(FixPointData, _impl_.pointx_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kFloat)},
+    // float pointY = 4;
+    {PROTOBUF_FIELD_OFFSET(FixPointData, _impl_.pointy_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kFloat)},
+    // uint32 duration = 5;
+    {PROTOBUF_FIELD_OFFSET(FixPointData, _impl_.duration_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kUInt32)},
+  }},
+  // no aux_entries
+  {{
+  }},
+};
+
+::uint8_t* FixPointData::_InternalSerialize(
+    ::uint8_t* target,
+    ::google::protobuf::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:stream.FixPointData)
+  ::uint32_t cached_has_bits = 0;
+  (void)cached_has_bits;
+
+  // int32 id = 1;
+  if (this->_internal_id() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt32ToArrayWithField<1>(
+            stream, this->_internal_id(), target);
+  }
+
+  // int32 cno = 2;
+  if (this->_internal_cno() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt32ToArrayWithField<2>(
+            stream, this->_internal_cno(), target);
+  }
+
+  // float pointX = 3;
+  static_assert(sizeof(::uint32_t) == sizeof(float),
+                "Code assumes ::uint32_t and float are the same size.");
+  float tmp_pointx = this->_internal_pointx();
+  ::uint32_t raw_pointx;
+  memcpy(&raw_pointx, &tmp_pointx, sizeof(tmp_pointx));
+  if (raw_pointx != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteFloatToArray(
+        3, this->_internal_pointx(), target);
+  }
+
+  // float pointY = 4;
+  static_assert(sizeof(::uint32_t) == sizeof(float),
+                "Code assumes ::uint32_t and float are the same size.");
+  float tmp_pointy = this->_internal_pointy();
+  ::uint32_t raw_pointy;
+  memcpy(&raw_pointy, &tmp_pointy, sizeof(tmp_pointy));
+  if (raw_pointy != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteFloatToArray(
+        4, this->_internal_pointy(), target);
+  }
+
+  // uint32 duration = 5;
+  if (this->_internal_duration() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
+        5, this->_internal_duration(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target =
+        ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
+            _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:stream.FixPointData)
+  return target;
+}
+
+::size_t FixPointData::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:stream.FixPointData)
+  ::size_t total_size = 0;
+
+  ::uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // int32 id = 1;
+  if (this->_internal_id() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
+        this->_internal_id());
+  }
+
+  // int32 cno = 2;
+  if (this->_internal_cno() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
+        this->_internal_cno());
+  }
+
+  // float pointX = 3;
+  static_assert(sizeof(::uint32_t) == sizeof(float),
+                "Code assumes ::uint32_t and float are the same size.");
+  float tmp_pointx = this->_internal_pointx();
+  ::uint32_t raw_pointx;
+  memcpy(&raw_pointx, &tmp_pointx, sizeof(tmp_pointx));
+  if (raw_pointx != 0) {
+    total_size += 5;
+  }
+
+  // float pointY = 4;
+  static_assert(sizeof(::uint32_t) == sizeof(float),
+                "Code assumes ::uint32_t and float are the same size.");
+  float tmp_pointy = this->_internal_pointy();
+  ::uint32_t raw_pointy;
+  memcpy(&raw_pointy, &tmp_pointy, sizeof(tmp_pointy));
+  if (raw_pointy != 0) {
+    total_size += 5;
+  }
+
+  // uint32 duration = 5;
+  if (this->_internal_duration() != 0) {
+    total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
+        this->_internal_duration());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::google::protobuf::Message::ClassData FixPointData::_class_data_ = {
+    ::google::protobuf::Message::CopyWithSourceCheck,
+    FixPointData::MergeImpl
+};
+const ::google::protobuf::Message::ClassData*FixPointData::GetClassData() const { return &_class_data_; }
+
+
+void FixPointData::MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg) {
+  auto* const _this = static_cast<FixPointData*>(&to_msg);
+  auto& from = static_cast<const FixPointData&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:stream.FixPointData)
+  ABSL_DCHECK_NE(&from, _this);
+  ::uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_id() != 0) {
+    _this->_internal_set_id(from._internal_id());
+  }
+  if (from._internal_cno() != 0) {
+    _this->_internal_set_cno(from._internal_cno());
+  }
+  static_assert(sizeof(::uint32_t) == sizeof(float),
+                "Code assumes ::uint32_t and float are the same size.");
+  float tmp_pointx = from._internal_pointx();
+  ::uint32_t raw_pointx;
+  memcpy(&raw_pointx, &tmp_pointx, sizeof(tmp_pointx));
+  if (raw_pointx != 0) {
+    _this->_internal_set_pointx(from._internal_pointx());
+  }
+  static_assert(sizeof(::uint32_t) == sizeof(float),
+                "Code assumes ::uint32_t and float are the same size.");
+  float tmp_pointy = from._internal_pointy();
+  ::uint32_t raw_pointy;
+  memcpy(&raw_pointy, &tmp_pointy, sizeof(tmp_pointy));
+  if (raw_pointy != 0) {
+    _this->_internal_set_pointy(from._internal_pointy());
+  }
+  if (from._internal_duration() != 0) {
+    _this->_internal_set_duration(from._internal_duration());
+  }
+  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void FixPointData::CopyFrom(const FixPointData& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:stream.FixPointData)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+PROTOBUF_NOINLINE bool FixPointData::IsInitialized() const {
+  return true;
+}
+
+void FixPointData::InternalSwap(FixPointData* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::google::protobuf::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(FixPointData, _impl_.duration_)
+      + sizeof(FixPointData::_impl_.duration_)
+      - PROTOBUF_FIELD_OFFSET(FixPointData, _impl_.id_)>(
+          reinterpret_cast<char*>(&_impl_.id_),
+          reinterpret_cast<char*>(&other->_impl_.id_));
+}
+
+::google::protobuf::Metadata FixPointData::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_stream_2eproto_getter, &descriptor_table_stream_2eproto_once,
+      file_level_metadata_stream_2eproto[14]);
+}
+// ===================================================================
+
+class ScanParamCfg::_Internal {
+ public:
+};
+
+ScanParamCfg::ScanParamCfg(::google::protobuf::Arena* arena)
+    : ::google::protobuf::Message(arena) {
+  SharedCtor(arena);
+  // @@protoc_insertion_point(arena_constructor:stream.ScanParamCfg)
+}
+ScanParamCfg::ScanParamCfg(const ScanParamCfg& from)
+    : ::google::protobuf::Message(), _impl_(from._impl_) {
+  _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
+      from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:stream.ScanParamCfg)
+}
+inline void ScanParamCfg::SharedCtor(::_pb::Arena* arena) {
+  (void)arena;
+  new (&_impl_) Impl_{
+      decltype(_impl_.edgelevel_){0},
+      decltype(_impl_.edgelevelmin_){0},
+      decltype(_impl_.edgelevelmax_){0},
+      decltype(_impl_.jumpdelay_){0u},
+      decltype(_impl_.jumpdelaymin_){0u},
+      decltype(_impl_.jumpdelaymax_){0u},
+      decltype(_impl_.scandelay_){0u},
+      decltype(_impl_.scandelaymin_){0u},
+      decltype(_impl_.scandelaymax_){0u},
+      decltype(_impl_.polygondelay_){0u},
+      decltype(_impl_.polygondelaymin_){0u},
+      decltype(_impl_.polygondelaymax_){0u},
+      decltype(_impl_.laseroffdelay_){::int64_t{0}},
+      decltype(_impl_.laseroffdelaymin_){::int64_t{0}},
+      decltype(_impl_.laseroffdelaymax_){::int64_t{0}},
+      decltype(_impl_.laserondelay_){::int64_t{0}},
+      decltype(_impl_.laserondelaymin_){::int64_t{0}},
+      decltype(_impl_.laserondelaymax_){::int64_t{0}},
+      decltype(_impl_.minjumpdelay_){0u},
+      decltype(_impl_.minjumpdelaymin_){0u},
+      decltype(_impl_.minjumpdelaymax_){0u},
+      decltype(_impl_.jumplengthlimit_){0u},
+      decltype(_impl_.jumplengthlimitmin_){0u},
+      decltype(_impl_.jumplengthlimitmax_){0u},
+      decltype(_impl_.jumpspeed_){0},
+      decltype(_impl_.jumpspeedmin_){0},
+      decltype(_impl_.jumpspeedmax_){0},
+      decltype(_impl_.markspeed_){0},
+      decltype(_impl_.markspeedmin_){0},
+      decltype(_impl_.markspeedmax_){0},
+      /*decltype(_impl_._cached_size_)*/ {},
+  };
+}
+ScanParamCfg::~ScanParamCfg() {
+  // @@protoc_insertion_point(destructor:stream.ScanParamCfg)
+  _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
+  SharedDtor();
+}
+inline void ScanParamCfg::SharedDtor() {
+  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
+}
+void ScanParamCfg::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+PROTOBUF_NOINLINE void ScanParamCfg::Clear() {
+// @@protoc_insertion_point(message_clear_start:stream.ScanParamCfg)
+  ::uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  ::memset(&_impl_.edgelevel_, 0, static_cast<::size_t>(
+      reinterpret_cast<char*>(&_impl_.markspeedmax_) -
+      reinterpret_cast<char*>(&_impl_.edgelevel_)) + sizeof(_impl_.markspeedmax_));
+  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
+}
+
+const char* ScanParamCfg::_InternalParse(
+    const char* ptr, ::_pbi::ParseContext* ctx) {
+  ptr = ::_pbi::TcParser::ParseLoop(this, ptr, ctx, &_table_.header);
+  return ptr;
+}
+
+
+PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
+const ::_pbi::TcParseTable<5, 30, 0, 0, 2> ScanParamCfg::_table_ = {
+  {
+    0,  // no _has_bits_
+    0, // no _extensions_
+    30, 248,  // max_field_number, fast_idx_mask
+    offsetof(decltype(_table_), field_lookup_table),
+    3221225472,  // skipmap
+    offsetof(decltype(_table_), field_entries),
+    30,  // num_field_entries
+    0,  // num_aux_entries
+    offsetof(decltype(_table_), field_names),  // no aux_entries
+    &_ScanParamCfg_default_instance_._instance,
+    ::_pbi::TcParser::GenericFallback,  // fallback
+  }, {{
+    {::_pbi::TcParser::MiniParse, {}},
+    // int32 edgeLevel = 1;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanParamCfg, _impl_.edgelevel_), 63>(),
+     {8, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.edgelevel_)}},
+    // int32 edgeLevelMin = 2;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanParamCfg, _impl_.edgelevelmin_), 63>(),
+     {16, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.edgelevelmin_)}},
+    // int32 edgeLevelMax = 3;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanParamCfg, _impl_.edgelevelmax_), 63>(),
+     {24, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.edgelevelmax_)}},
+    // uint32 jumpDelay = 4;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanParamCfg, _impl_.jumpdelay_), 63>(),
+     {32, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumpdelay_)}},
+    // uint32 jumpDelayMin = 5;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanParamCfg, _impl_.jumpdelaymin_), 63>(),
+     {40, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumpdelaymin_)}},
+    // uint32 jumpDelayMax = 6;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanParamCfg, _impl_.jumpdelaymax_), 63>(),
+     {48, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumpdelaymax_)}},
+    // uint32 scanDelay = 7;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanParamCfg, _impl_.scandelay_), 63>(),
+     {56, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.scandelay_)}},
+    // uint32 scanDelayMin = 8;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanParamCfg, _impl_.scandelaymin_), 63>(),
+     {64, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.scandelaymin_)}},
+    // uint32 scanDelayMax = 9;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanParamCfg, _impl_.scandelaymax_), 63>(),
+     {72, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.scandelaymax_)}},
+    // uint32 polygonDelay = 10;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanParamCfg, _impl_.polygondelay_), 63>(),
+     {80, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.polygondelay_)}},
+    // uint32 polygonDelayMin = 11;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanParamCfg, _impl_.polygondelaymin_), 63>(),
+     {88, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.polygondelaymin_)}},
+    // uint32 polygonDelayMax = 12;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanParamCfg, _impl_.polygondelaymax_), 63>(),
+     {96, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.polygondelaymax_)}},
+    // int64 laseroffDelay = 13;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(ScanParamCfg, _impl_.laseroffdelay_), 63>(),
+     {104, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.laseroffdelay_)}},
+    // int64 laseroffDelayMin = 14;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(ScanParamCfg, _impl_.laseroffdelaymin_), 63>(),
+     {112, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.laseroffdelaymin_)}},
+    // int64 laseroffDelayMax = 15;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(ScanParamCfg, _impl_.laseroffdelaymax_), 63>(),
+     {120, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.laseroffdelaymax_)}},
+    // int64 laseronDelay = 16;
+    {::_pbi::TcParser::FastV64S2,
+     {384, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.laserondelay_)}},
+    // int64 laseronDelayMin = 17;
+    {::_pbi::TcParser::FastV64S2,
+     {392, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.laserondelaymin_)}},
+    // int64 laseronDelayMax = 18;
+    {::_pbi::TcParser::FastV64S2,
+     {400, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.laserondelaymax_)}},
+    // uint32 minJumpDelay = 19;
+    {::_pbi::TcParser::FastV32S2,
+     {408, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.minjumpdelay_)}},
+    // uint32 minJumpDelayMin = 20;
+    {::_pbi::TcParser::FastV32S2,
+     {416, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.minjumpdelaymin_)}},
+    // uint32 minJumpDelayMax = 21;
+    {::_pbi::TcParser::FastV32S2,
+     {424, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.minjumpdelaymax_)}},
+    // uint32 jumpLengthLimit = 22;
+    {::_pbi::TcParser::FastV32S2,
+     {432, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumplengthlimit_)}},
+    // uint32 jumpLengthLimitMin = 23;
+    {::_pbi::TcParser::FastV32S2,
+     {440, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumplengthlimitmin_)}},
+    // uint32 jumpLengthLimitMax = 24;
+    {::_pbi::TcParser::FastV32S2,
+     {448, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumplengthlimitmax_)}},
+    // double jumpSpeed = 25;
+    {::_pbi::TcParser::FastF64S2,
+     {457, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumpspeed_)}},
+    // double jumpSpeedMin = 26;
+    {::_pbi::TcParser::FastF64S2,
+     {465, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumpspeedmin_)}},
+    // double jumpSpeedMax = 27;
+    {::_pbi::TcParser::FastF64S2,
+     {473, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumpspeedmax_)}},
+    // double markSpeed = 28;
+    {::_pbi::TcParser::FastF64S2,
+     {481, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.markspeed_)}},
+    // double markSpeedMin = 29;
+    {::_pbi::TcParser::FastF64S2,
+     {489, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.markspeedmin_)}},
+    // double markSpeedMax = 30;
+    {::_pbi::TcParser::FastF64S2,
+     {497, 63, 0, PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.markspeedmax_)}},
+    {::_pbi::TcParser::MiniParse, {}},
+  }}, {{
+    65535, 65535
+  }}, {{
+    // int32 edgeLevel = 1;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.edgelevel_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt32)},
+    // int32 edgeLevelMin = 2;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.edgelevelmin_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt32)},
+    // int32 edgeLevelMax = 3;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.edgelevelmax_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt32)},
+    // uint32 jumpDelay = 4;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumpdelay_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kUInt32)},
+    // uint32 jumpDelayMin = 5;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumpdelaymin_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kUInt32)},
+    // uint32 jumpDelayMax = 6;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumpdelaymax_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kUInt32)},
+    // uint32 scanDelay = 7;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.scandelay_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kUInt32)},
+    // uint32 scanDelayMin = 8;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.scandelaymin_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kUInt32)},
+    // uint32 scanDelayMax = 9;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.scandelaymax_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kUInt32)},
+    // uint32 polygonDelay = 10;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.polygondelay_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kUInt32)},
+    // uint32 polygonDelayMin = 11;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.polygondelaymin_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kUInt32)},
+    // uint32 polygonDelayMax = 12;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.polygondelaymax_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kUInt32)},
+    // int64 laseroffDelay = 13;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.laseroffdelay_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt64)},
+    // int64 laseroffDelayMin = 14;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.laseroffdelaymin_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt64)},
+    // int64 laseroffDelayMax = 15;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.laseroffdelaymax_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt64)},
+    // int64 laseronDelay = 16;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.laserondelay_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt64)},
+    // int64 laseronDelayMin = 17;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.laserondelaymin_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt64)},
+    // int64 laseronDelayMax = 18;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.laserondelaymax_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt64)},
+    // uint32 minJumpDelay = 19;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.minjumpdelay_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kUInt32)},
+    // uint32 minJumpDelayMin = 20;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.minjumpdelaymin_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kUInt32)},
+    // uint32 minJumpDelayMax = 21;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.minjumpdelaymax_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kUInt32)},
+    // uint32 jumpLengthLimit = 22;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumplengthlimit_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kUInt32)},
+    // uint32 jumpLengthLimitMin = 23;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumplengthlimitmin_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kUInt32)},
+    // uint32 jumpLengthLimitMax = 24;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumplengthlimitmax_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kUInt32)},
+    // double jumpSpeed = 25;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumpspeed_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double jumpSpeedMin = 26;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumpspeedmin_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double jumpSpeedMax = 27;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.jumpspeedmax_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double markSpeed = 28;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.markspeed_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double markSpeedMin = 29;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.markspeedmin_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double markSpeedMax = 30;
+    {PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.markspeedmax_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+  }},
+  // no aux_entries
+  {{
+  }},
+};
+
+::uint8_t* ScanParamCfg::_InternalSerialize(
+    ::uint8_t* target,
+    ::google::protobuf::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:stream.ScanParamCfg)
+  ::uint32_t cached_has_bits = 0;
+  (void)cached_has_bits;
+
+  // int32 edgeLevel = 1;
+  if (this->_internal_edgelevel() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt32ToArrayWithField<1>(
+            stream, this->_internal_edgelevel(), target);
+  }
+
+  // int32 edgeLevelMin = 2;
+  if (this->_internal_edgelevelmin() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt32ToArrayWithField<2>(
+            stream, this->_internal_edgelevelmin(), target);
+  }
+
+  // int32 edgeLevelMax = 3;
+  if (this->_internal_edgelevelmax() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt32ToArrayWithField<3>(
+            stream, this->_internal_edgelevelmax(), target);
+  }
+
+  // uint32 jumpDelay = 4;
+  if (this->_internal_jumpdelay() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
+        4, this->_internal_jumpdelay(), target);
+  }
+
+  // uint32 jumpDelayMin = 5;
+  if (this->_internal_jumpdelaymin() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
+        5, this->_internal_jumpdelaymin(), target);
+  }
+
+  // uint32 jumpDelayMax = 6;
+  if (this->_internal_jumpdelaymax() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
+        6, this->_internal_jumpdelaymax(), target);
+  }
+
+  // uint32 scanDelay = 7;
+  if (this->_internal_scandelay() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
+        7, this->_internal_scandelay(), target);
+  }
+
+  // uint32 scanDelayMin = 8;
+  if (this->_internal_scandelaymin() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
+        8, this->_internal_scandelaymin(), target);
+  }
+
+  // uint32 scanDelayMax = 9;
+  if (this->_internal_scandelaymax() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
+        9, this->_internal_scandelaymax(), target);
+  }
+
+  // uint32 polygonDelay = 10;
+  if (this->_internal_polygondelay() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
+        10, this->_internal_polygondelay(), target);
+  }
+
+  // uint32 polygonDelayMin = 11;
+  if (this->_internal_polygondelaymin() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
+        11, this->_internal_polygondelaymin(), target);
+  }
+
+  // uint32 polygonDelayMax = 12;
+  if (this->_internal_polygondelaymax() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
+        12, this->_internal_polygondelaymax(), target);
+  }
+
+  // int64 laseroffDelay = 13;
+  if (this->_internal_laseroffdelay() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt64ToArrayWithField<13>(
+            stream, this->_internal_laseroffdelay(), target);
+  }
+
+  // int64 laseroffDelayMin = 14;
+  if (this->_internal_laseroffdelaymin() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt64ToArrayWithField<14>(
+            stream, this->_internal_laseroffdelaymin(), target);
+  }
+
+  // int64 laseroffDelayMax = 15;
+  if (this->_internal_laseroffdelaymax() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt64ToArrayWithField<15>(
+            stream, this->_internal_laseroffdelaymax(), target);
+  }
+
+  // int64 laseronDelay = 16;
+  if (this->_internal_laserondelay() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(
+        16, this->_internal_laserondelay(), target);
+  }
+
+  // int64 laseronDelayMin = 17;
+  if (this->_internal_laserondelaymin() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(
+        17, this->_internal_laserondelaymin(), target);
+  }
+
+  // int64 laseronDelayMax = 18;
+  if (this->_internal_laserondelaymax() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(
+        18, this->_internal_laserondelaymax(), target);
+  }
+
+  // uint32 minJumpDelay = 19;
+  if (this->_internal_minjumpdelay() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
+        19, this->_internal_minjumpdelay(), target);
+  }
+
+  // uint32 minJumpDelayMin = 20;
+  if (this->_internal_minjumpdelaymin() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
+        20, this->_internal_minjumpdelaymin(), target);
+  }
+
+  // uint32 minJumpDelayMax = 21;
+  if (this->_internal_minjumpdelaymax() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
+        21, this->_internal_minjumpdelaymax(), target);
+  }
+
+  // uint32 jumpLengthLimit = 22;
+  if (this->_internal_jumplengthlimit() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
+        22, this->_internal_jumplengthlimit(), target);
+  }
+
+  // uint32 jumpLengthLimitMin = 23;
+  if (this->_internal_jumplengthlimitmin() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
+        23, this->_internal_jumplengthlimitmin(), target);
+  }
+
+  // uint32 jumpLengthLimitMax = 24;
+  if (this->_internal_jumplengthlimitmax() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
+        24, this->_internal_jumplengthlimitmax(), target);
+  }
+
+  // double jumpSpeed = 25;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_jumpspeed = this->_internal_jumpspeed();
+  ::uint64_t raw_jumpspeed;
+  memcpy(&raw_jumpspeed, &tmp_jumpspeed, sizeof(tmp_jumpspeed));
+  if (raw_jumpspeed != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        25, this->_internal_jumpspeed(), target);
+  }
+
+  // double jumpSpeedMin = 26;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_jumpspeedmin = this->_internal_jumpspeedmin();
+  ::uint64_t raw_jumpspeedmin;
+  memcpy(&raw_jumpspeedmin, &tmp_jumpspeedmin, sizeof(tmp_jumpspeedmin));
+  if (raw_jumpspeedmin != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        26, this->_internal_jumpspeedmin(), target);
+  }
+
+  // double jumpSpeedMax = 27;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_jumpspeedmax = this->_internal_jumpspeedmax();
+  ::uint64_t raw_jumpspeedmax;
+  memcpy(&raw_jumpspeedmax, &tmp_jumpspeedmax, sizeof(tmp_jumpspeedmax));
+  if (raw_jumpspeedmax != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        27, this->_internal_jumpspeedmax(), target);
+  }
+
+  // double markSpeed = 28;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_markspeed = this->_internal_markspeed();
+  ::uint64_t raw_markspeed;
+  memcpy(&raw_markspeed, &tmp_markspeed, sizeof(tmp_markspeed));
+  if (raw_markspeed != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        28, this->_internal_markspeed(), target);
+  }
+
+  // double markSpeedMin = 29;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_markspeedmin = this->_internal_markspeedmin();
+  ::uint64_t raw_markspeedmin;
+  memcpy(&raw_markspeedmin, &tmp_markspeedmin, sizeof(tmp_markspeedmin));
+  if (raw_markspeedmin != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        29, this->_internal_markspeedmin(), target);
+  }
+
+  // double markSpeedMax = 30;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_markspeedmax = this->_internal_markspeedmax();
+  ::uint64_t raw_markspeedmax;
+  memcpy(&raw_markspeedmax, &tmp_markspeedmax, sizeof(tmp_markspeedmax));
+  if (raw_markspeedmax != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        30, this->_internal_markspeedmax(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target =
+        ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
+            _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:stream.ScanParamCfg)
+  return target;
+}
+
+::size_t ScanParamCfg::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:stream.ScanParamCfg)
+  ::size_t total_size = 0;
+
+  ::uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // int32 edgeLevel = 1;
+  if (this->_internal_edgelevel() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
+        this->_internal_edgelevel());
+  }
+
+  // int32 edgeLevelMin = 2;
+  if (this->_internal_edgelevelmin() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
+        this->_internal_edgelevelmin());
+  }
+
+  // int32 edgeLevelMax = 3;
+  if (this->_internal_edgelevelmax() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
+        this->_internal_edgelevelmax());
+  }
+
+  // uint32 jumpDelay = 4;
+  if (this->_internal_jumpdelay() != 0) {
+    total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
+        this->_internal_jumpdelay());
+  }
+
+  // uint32 jumpDelayMin = 5;
+  if (this->_internal_jumpdelaymin() != 0) {
+    total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
+        this->_internal_jumpdelaymin());
+  }
+
+  // uint32 jumpDelayMax = 6;
+  if (this->_internal_jumpdelaymax() != 0) {
+    total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
+        this->_internal_jumpdelaymax());
+  }
+
+  // uint32 scanDelay = 7;
+  if (this->_internal_scandelay() != 0) {
+    total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
+        this->_internal_scandelay());
+  }
+
+  // uint32 scanDelayMin = 8;
+  if (this->_internal_scandelaymin() != 0) {
+    total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
+        this->_internal_scandelaymin());
+  }
+
+  // uint32 scanDelayMax = 9;
+  if (this->_internal_scandelaymax() != 0) {
+    total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
+        this->_internal_scandelaymax());
+  }
+
+  // uint32 polygonDelay = 10;
+  if (this->_internal_polygondelay() != 0) {
+    total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
+        this->_internal_polygondelay());
+  }
+
+  // uint32 polygonDelayMin = 11;
+  if (this->_internal_polygondelaymin() != 0) {
+    total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
+        this->_internal_polygondelaymin());
+  }
+
+  // uint32 polygonDelayMax = 12;
+  if (this->_internal_polygondelaymax() != 0) {
+    total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
+        this->_internal_polygondelaymax());
+  }
+
+  // int64 laseroffDelay = 13;
+  if (this->_internal_laseroffdelay() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(
+        this->_internal_laseroffdelay());
+  }
+
+  // int64 laseroffDelayMin = 14;
+  if (this->_internal_laseroffdelaymin() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(
+        this->_internal_laseroffdelaymin());
+  }
+
+  // int64 laseroffDelayMax = 15;
+  if (this->_internal_laseroffdelaymax() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(
+        this->_internal_laseroffdelaymax());
+  }
+
+  // int64 laseronDelay = 16;
+  if (this->_internal_laserondelay() != 0) {
+    total_size += 2 + ::_pbi::WireFormatLite::Int64Size(
+                                    this->_internal_laserondelay());
+  }
+
+  // int64 laseronDelayMin = 17;
+  if (this->_internal_laserondelaymin() != 0) {
+    total_size += 2 + ::_pbi::WireFormatLite::Int64Size(
+                                    this->_internal_laserondelaymin());
+  }
+
+  // int64 laseronDelayMax = 18;
+  if (this->_internal_laserondelaymax() != 0) {
+    total_size += 2 + ::_pbi::WireFormatLite::Int64Size(
+                                    this->_internal_laserondelaymax());
+  }
+
+  // uint32 minJumpDelay = 19;
+  if (this->_internal_minjumpdelay() != 0) {
+    total_size += 2 + ::_pbi::WireFormatLite::UInt32Size(
+                                    this->_internal_minjumpdelay());
+  }
+
+  // uint32 minJumpDelayMin = 20;
+  if (this->_internal_minjumpdelaymin() != 0) {
+    total_size += 2 + ::_pbi::WireFormatLite::UInt32Size(
+                                    this->_internal_minjumpdelaymin());
+  }
+
+  // uint32 minJumpDelayMax = 21;
+  if (this->_internal_minjumpdelaymax() != 0) {
+    total_size += 2 + ::_pbi::WireFormatLite::UInt32Size(
+                                    this->_internal_minjumpdelaymax());
+  }
+
+  // uint32 jumpLengthLimit = 22;
+  if (this->_internal_jumplengthlimit() != 0) {
+    total_size += 2 + ::_pbi::WireFormatLite::UInt32Size(
+                                    this->_internal_jumplengthlimit());
+  }
+
+  // uint32 jumpLengthLimitMin = 23;
+  if (this->_internal_jumplengthlimitmin() != 0) {
+    total_size += 2 + ::_pbi::WireFormatLite::UInt32Size(
+                                    this->_internal_jumplengthlimitmin());
+  }
+
+  // uint32 jumpLengthLimitMax = 24;
+  if (this->_internal_jumplengthlimitmax() != 0) {
+    total_size += 2 + ::_pbi::WireFormatLite::UInt32Size(
+                                    this->_internal_jumplengthlimitmax());
+  }
+
+  // double jumpSpeed = 25;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_jumpspeed = this->_internal_jumpspeed();
+  ::uint64_t raw_jumpspeed;
+  memcpy(&raw_jumpspeed, &tmp_jumpspeed, sizeof(tmp_jumpspeed));
+  if (raw_jumpspeed != 0) {
+    total_size += 10;
+  }
+
+  // double jumpSpeedMin = 26;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_jumpspeedmin = this->_internal_jumpspeedmin();
+  ::uint64_t raw_jumpspeedmin;
+  memcpy(&raw_jumpspeedmin, &tmp_jumpspeedmin, sizeof(tmp_jumpspeedmin));
+  if (raw_jumpspeedmin != 0) {
+    total_size += 10;
+  }
+
+  // double jumpSpeedMax = 27;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_jumpspeedmax = this->_internal_jumpspeedmax();
+  ::uint64_t raw_jumpspeedmax;
+  memcpy(&raw_jumpspeedmax, &tmp_jumpspeedmax, sizeof(tmp_jumpspeedmax));
+  if (raw_jumpspeedmax != 0) {
+    total_size += 10;
+  }
+
+  // double markSpeed = 28;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_markspeed = this->_internal_markspeed();
+  ::uint64_t raw_markspeed;
+  memcpy(&raw_markspeed, &tmp_markspeed, sizeof(tmp_markspeed));
+  if (raw_markspeed != 0) {
+    total_size += 10;
+  }
+
+  // double markSpeedMin = 29;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_markspeedmin = this->_internal_markspeedmin();
+  ::uint64_t raw_markspeedmin;
+  memcpy(&raw_markspeedmin, &tmp_markspeedmin, sizeof(tmp_markspeedmin));
+  if (raw_markspeedmin != 0) {
+    total_size += 10;
+  }
+
+  // double markSpeedMax = 30;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_markspeedmax = this->_internal_markspeedmax();
+  ::uint64_t raw_markspeedmax;
+  memcpy(&raw_markspeedmax, &tmp_markspeedmax, sizeof(tmp_markspeedmax));
+  if (raw_markspeedmax != 0) {
+    total_size += 10;
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::google::protobuf::Message::ClassData ScanParamCfg::_class_data_ = {
+    ::google::protobuf::Message::CopyWithSourceCheck,
+    ScanParamCfg::MergeImpl
+};
+const ::google::protobuf::Message::ClassData*ScanParamCfg::GetClassData() const { return &_class_data_; }
+
+
+void ScanParamCfg::MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg) {
+  auto* const _this = static_cast<ScanParamCfg*>(&to_msg);
+  auto& from = static_cast<const ScanParamCfg&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:stream.ScanParamCfg)
+  ABSL_DCHECK_NE(&from, _this);
+  ::uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_edgelevel() != 0) {
+    _this->_internal_set_edgelevel(from._internal_edgelevel());
+  }
+  if (from._internal_edgelevelmin() != 0) {
+    _this->_internal_set_edgelevelmin(from._internal_edgelevelmin());
+  }
+  if (from._internal_edgelevelmax() != 0) {
+    _this->_internal_set_edgelevelmax(from._internal_edgelevelmax());
+  }
+  if (from._internal_jumpdelay() != 0) {
+    _this->_internal_set_jumpdelay(from._internal_jumpdelay());
+  }
+  if (from._internal_jumpdelaymin() != 0) {
+    _this->_internal_set_jumpdelaymin(from._internal_jumpdelaymin());
+  }
+  if (from._internal_jumpdelaymax() != 0) {
+    _this->_internal_set_jumpdelaymax(from._internal_jumpdelaymax());
+  }
+  if (from._internal_scandelay() != 0) {
+    _this->_internal_set_scandelay(from._internal_scandelay());
+  }
+  if (from._internal_scandelaymin() != 0) {
+    _this->_internal_set_scandelaymin(from._internal_scandelaymin());
+  }
+  if (from._internal_scandelaymax() != 0) {
+    _this->_internal_set_scandelaymax(from._internal_scandelaymax());
+  }
+  if (from._internal_polygondelay() != 0) {
+    _this->_internal_set_polygondelay(from._internal_polygondelay());
+  }
+  if (from._internal_polygondelaymin() != 0) {
+    _this->_internal_set_polygondelaymin(from._internal_polygondelaymin());
+  }
+  if (from._internal_polygondelaymax() != 0) {
+    _this->_internal_set_polygondelaymax(from._internal_polygondelaymax());
+  }
+  if (from._internal_laseroffdelay() != 0) {
+    _this->_internal_set_laseroffdelay(from._internal_laseroffdelay());
+  }
+  if (from._internal_laseroffdelaymin() != 0) {
+    _this->_internal_set_laseroffdelaymin(from._internal_laseroffdelaymin());
+  }
+  if (from._internal_laseroffdelaymax() != 0) {
+    _this->_internal_set_laseroffdelaymax(from._internal_laseroffdelaymax());
+  }
+  if (from._internal_laserondelay() != 0) {
+    _this->_internal_set_laserondelay(from._internal_laserondelay());
+  }
+  if (from._internal_laserondelaymin() != 0) {
+    _this->_internal_set_laserondelaymin(from._internal_laserondelaymin());
+  }
+  if (from._internal_laserondelaymax() != 0) {
+    _this->_internal_set_laserondelaymax(from._internal_laserondelaymax());
+  }
+  if (from._internal_minjumpdelay() != 0) {
+    _this->_internal_set_minjumpdelay(from._internal_minjumpdelay());
+  }
+  if (from._internal_minjumpdelaymin() != 0) {
+    _this->_internal_set_minjumpdelaymin(from._internal_minjumpdelaymin());
+  }
+  if (from._internal_minjumpdelaymax() != 0) {
+    _this->_internal_set_minjumpdelaymax(from._internal_minjumpdelaymax());
+  }
+  if (from._internal_jumplengthlimit() != 0) {
+    _this->_internal_set_jumplengthlimit(from._internal_jumplengthlimit());
+  }
+  if (from._internal_jumplengthlimitmin() != 0) {
+    _this->_internal_set_jumplengthlimitmin(from._internal_jumplengthlimitmin());
+  }
+  if (from._internal_jumplengthlimitmax() != 0) {
+    _this->_internal_set_jumplengthlimitmax(from._internal_jumplengthlimitmax());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_jumpspeed = from._internal_jumpspeed();
+  ::uint64_t raw_jumpspeed;
+  memcpy(&raw_jumpspeed, &tmp_jumpspeed, sizeof(tmp_jumpspeed));
+  if (raw_jumpspeed != 0) {
+    _this->_internal_set_jumpspeed(from._internal_jumpspeed());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_jumpspeedmin = from._internal_jumpspeedmin();
+  ::uint64_t raw_jumpspeedmin;
+  memcpy(&raw_jumpspeedmin, &tmp_jumpspeedmin, sizeof(tmp_jumpspeedmin));
+  if (raw_jumpspeedmin != 0) {
+    _this->_internal_set_jumpspeedmin(from._internal_jumpspeedmin());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_jumpspeedmax = from._internal_jumpspeedmax();
+  ::uint64_t raw_jumpspeedmax;
+  memcpy(&raw_jumpspeedmax, &tmp_jumpspeedmax, sizeof(tmp_jumpspeedmax));
+  if (raw_jumpspeedmax != 0) {
+    _this->_internal_set_jumpspeedmax(from._internal_jumpspeedmax());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_markspeed = from._internal_markspeed();
+  ::uint64_t raw_markspeed;
+  memcpy(&raw_markspeed, &tmp_markspeed, sizeof(tmp_markspeed));
+  if (raw_markspeed != 0) {
+    _this->_internal_set_markspeed(from._internal_markspeed());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_markspeedmin = from._internal_markspeedmin();
+  ::uint64_t raw_markspeedmin;
+  memcpy(&raw_markspeedmin, &tmp_markspeedmin, sizeof(tmp_markspeedmin));
+  if (raw_markspeedmin != 0) {
+    _this->_internal_set_markspeedmin(from._internal_markspeedmin());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_markspeedmax = from._internal_markspeedmax();
+  ::uint64_t raw_markspeedmax;
+  memcpy(&raw_markspeedmax, &tmp_markspeedmax, sizeof(tmp_markspeedmax));
+  if (raw_markspeedmax != 0) {
+    _this->_internal_set_markspeedmax(from._internal_markspeedmax());
+  }
+  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ScanParamCfg::CopyFrom(const ScanParamCfg& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:stream.ScanParamCfg)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+PROTOBUF_NOINLINE bool ScanParamCfg::IsInitialized() const {
+  return true;
+}
+
+void ScanParamCfg::InternalSwap(ScanParamCfg* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::google::protobuf::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.markspeedmax_)
+      + sizeof(ScanParamCfg::_impl_.markspeedmax_)
+      - PROTOBUF_FIELD_OFFSET(ScanParamCfg, _impl_.edgelevel_)>(
+          reinterpret_cast<char*>(&_impl_.edgelevel_),
+          reinterpret_cast<char*>(&other->_impl_.edgelevel_));
+}
+
+::google::protobuf::Metadata ScanParamCfg::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_stream_2eproto_getter, &descriptor_table_stream_2eproto_once,
+      file_level_metadata_stream_2eproto[15]);
+}
+// ===================================================================
+
+class CorrectParamCfg::_Internal {
+ public:
+};
+
+CorrectParamCfg::CorrectParamCfg(::google::protobuf::Arena* arena)
+    : ::google::protobuf::Message(arena) {
+  SharedCtor(arena);
+  // @@protoc_insertion_point(arena_constructor:stream.CorrectParamCfg)
+}
+CorrectParamCfg::CorrectParamCfg(const CorrectParamCfg& from)
+    : ::google::protobuf::Message(), _impl_(from._impl_) {
+  _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
+      from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:stream.CorrectParamCfg)
+}
+inline void CorrectParamCfg::SharedCtor(::_pb::Arena* arena) {
+  (void)arena;
+  new (&_impl_) Impl_{
+      decltype(_impl_.xmeasuremin_){0},
+      decltype(_impl_.xmeasuremax_){0},
+      decltype(_impl_.ymeasuremin_){0},
+      decltype(_impl_.ymeasuremax_){0},
+      decltype(_impl_.xposfix_){0},
+      decltype(_impl_.yposfix_){0},
+      decltype(_impl_.scanangle_){0},
+      decltype(_impl_.scananglemin_){0},
+      decltype(_impl_.scananglemax_){0},
+      decltype(_impl_.fixangle_){0},
+      decltype(_impl_.fixanglemin_){0},
+      decltype(_impl_.fixanglemax_){0},
+      decltype(_impl_.xcorrect_){0},
+      decltype(_impl_.ycorrect_){0},
+      decltype(_impl_.xcorrectmin_){0},
+      decltype(_impl_.xcorrectmax_){0},
+      decltype(_impl_.ycorrectmin_){0},
+      decltype(_impl_.ycorrectmax_){0},
+      decltype(_impl_.realxoffset_){0},
+      decltype(_impl_.realyoffset_){0},
+      decltype(_impl_.factork_){0},
+      decltype(_impl_.defocusratio_){0},
+      decltype(_impl_.defocusratiomin_){0},
+      decltype(_impl_.defocusratiomax_){0},
+      decltype(_impl_.iscorrectfile3d_){false},
+      decltype(_impl_.isdynamicfocus_){false},
+      /*decltype(_impl_._cached_size_)*/ {},
+  };
+}
+CorrectParamCfg::~CorrectParamCfg() {
+  // @@protoc_insertion_point(destructor:stream.CorrectParamCfg)
+  _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
+  SharedDtor();
+}
+inline void CorrectParamCfg::SharedDtor() {
+  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
+}
+void CorrectParamCfg::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+PROTOBUF_NOINLINE void CorrectParamCfg::Clear() {
+// @@protoc_insertion_point(message_clear_start:stream.CorrectParamCfg)
+  ::uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  ::memset(&_impl_.xmeasuremin_, 0, static_cast<::size_t>(
+      reinterpret_cast<char*>(&_impl_.isdynamicfocus_) -
+      reinterpret_cast<char*>(&_impl_.xmeasuremin_)) + sizeof(_impl_.isdynamicfocus_));
+  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
+}
+
+const char* CorrectParamCfg::_InternalParse(
+    const char* ptr, ::_pbi::ParseContext* ctx) {
+  ptr = ::_pbi::TcParser::ParseLoop(this, ptr, ctx, &_table_.header);
+  return ptr;
+}
+
+
+PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
+const ::_pbi::TcParseTable<5, 26, 0, 0, 2> CorrectParamCfg::_table_ = {
+  {
+    0,  // no _has_bits_
+    0, // no _extensions_
+    26, 248,  // max_field_number, fast_idx_mask
+    offsetof(decltype(_table_), field_lookup_table),
+    4227858432,  // skipmap
+    offsetof(decltype(_table_), field_entries),
+    26,  // num_field_entries
+    0,  // num_aux_entries
+    offsetof(decltype(_table_), field_names),  // no aux_entries
+    &_CorrectParamCfg_default_instance_._instance,
+    ::_pbi::TcParser::GenericFallback,  // fallback
+  }, {{
+    {::_pbi::TcParser::MiniParse, {}},
+    // double xmeasureMin = 1;
+    {::_pbi::TcParser::FastF64S1,
+     {9, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.xmeasuremin_)}},
+    // double xmeasureMax = 2;
+    {::_pbi::TcParser::FastF64S1,
+     {17, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.xmeasuremax_)}},
+    // double ymeasureMin = 3;
+    {::_pbi::TcParser::FastF64S1,
+     {25, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.ymeasuremin_)}},
+    // double ymeasureMax = 4;
+    {::_pbi::TcParser::FastF64S1,
+     {33, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.ymeasuremax_)}},
+    // double xposfix = 5;
+    {::_pbi::TcParser::FastF64S1,
+     {41, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.xposfix_)}},
+    // double yposfix = 6;
+    {::_pbi::TcParser::FastF64S1,
+     {49, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.yposfix_)}},
+    // double scanAngle = 7;
+    {::_pbi::TcParser::FastF64S1,
+     {57, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.scanangle_)}},
+    // double scanAngleMin = 8;
+    {::_pbi::TcParser::FastF64S1,
+     {65, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.scananglemin_)}},
+    // double scanAngleMax = 9;
+    {::_pbi::TcParser::FastF64S1,
+     {73, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.scananglemax_)}},
+    // double fixAngle = 10;
+    {::_pbi::TcParser::FastF64S1,
+     {81, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.fixangle_)}},
+    // double fixAngleMin = 11;
+    {::_pbi::TcParser::FastF64S1,
+     {89, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.fixanglemin_)}},
+    // double fixAngleMax = 12;
+    {::_pbi::TcParser::FastF64S1,
+     {97, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.fixanglemax_)}},
+    // double xcorrect = 13;
+    {::_pbi::TcParser::FastF64S1,
+     {105, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.xcorrect_)}},
+    // double ycorrect = 14;
+    {::_pbi::TcParser::FastF64S1,
+     {113, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.ycorrect_)}},
+    // double xcorrectMin = 15;
+    {::_pbi::TcParser::FastF64S1,
+     {121, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.xcorrectmin_)}},
+    // double xcorrectMax = 16;
+    {::_pbi::TcParser::FastF64S2,
+     {385, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.xcorrectmax_)}},
+    // double ycorrectMin = 17;
+    {::_pbi::TcParser::FastF64S2,
+     {393, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.ycorrectmin_)}},
+    // double ycorrectMax = 18;
+    {::_pbi::TcParser::FastF64S2,
+     {401, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.ycorrectmax_)}},
+    // double realXOffset = 19;
+    {::_pbi::TcParser::FastF64S2,
+     {409, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.realxoffset_)}},
+    // double realYOffset = 20;
+    {::_pbi::TcParser::FastF64S2,
+     {417, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.realyoffset_)}},
+    // double factorK = 21;
+    {::_pbi::TcParser::FastF64S2,
+     {425, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.factork_)}},
+    // bool isCorrectFile3D = 22;
+    {::_pbi::TcParser::FastV8S2,
+     {432, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.iscorrectfile3d_)}},
+    // bool isDynamicFocus = 23;
+    {::_pbi::TcParser::FastV8S2,
+     {440, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.isdynamicfocus_)}},
+    // double defocusRatio = 24;
+    {::_pbi::TcParser::FastF64S2,
+     {449, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.defocusratio_)}},
+    // double defocusRatioMin = 25;
+    {::_pbi::TcParser::FastF64S2,
+     {457, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.defocusratiomin_)}},
+    // double defocusRatioMax = 26;
+    {::_pbi::TcParser::FastF64S2,
+     {465, 63, 0, PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.defocusratiomax_)}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+  }}, {{
+    65535, 65535
+  }}, {{
+    // double xmeasureMin = 1;
+    {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.xmeasuremin_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double xmeasureMax = 2;
+    {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.xmeasuremax_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double ymeasureMin = 3;
+    {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.ymeasuremin_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double ymeasureMax = 4;
+    {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.ymeasuremax_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double xposfix = 5;
+    {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.xposfix_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double yposfix = 6;
+    {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.yposfix_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double scanAngle = 7;
+    {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.scanangle_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double scanAngleMin = 8;
+    {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.scananglemin_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double scanAngleMax = 9;
+    {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.scananglemax_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double fixAngle = 10;
+    {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.fixangle_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double fixAngleMin = 11;
+    {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.fixanglemin_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double fixAngleMax = 12;
+    {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.fixanglemax_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double xcorrect = 13;
+    {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.xcorrect_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double ycorrect = 14;
+    {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.ycorrect_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double xcorrectMin = 15;
+    {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.xcorrectmin_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double xcorrectMax = 16;
+    {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.xcorrectmax_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double ycorrectMin = 17;
+    {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.ycorrectmin_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double ycorrectMax = 18;
+    {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.ycorrectmax_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double realXOffset = 19;
+    {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.realxoffset_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double realYOffset = 20;
+    {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.realyoffset_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double factorK = 21;
+    {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.factork_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // bool isCorrectFile3D = 22;
+    {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.iscorrectfile3d_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kBool)},
+    // bool isDynamicFocus = 23;
+    {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.isdynamicfocus_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kBool)},
+    // double defocusRatio = 24;
+    {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.defocusratio_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double defocusRatioMin = 25;
+    {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.defocusratiomin_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double defocusRatioMax = 26;
+    {PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.defocusratiomax_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+  }},
+  // no aux_entries
+  {{
+  }},
+};
+
+::uint8_t* CorrectParamCfg::_InternalSerialize(
+    ::uint8_t* target,
+    ::google::protobuf::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:stream.CorrectParamCfg)
+  ::uint32_t cached_has_bits = 0;
+  (void)cached_has_bits;
+
+  // double xmeasureMin = 1;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_xmeasuremin = this->_internal_xmeasuremin();
+  ::uint64_t raw_xmeasuremin;
+  memcpy(&raw_xmeasuremin, &tmp_xmeasuremin, sizeof(tmp_xmeasuremin));
+  if (raw_xmeasuremin != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        1, this->_internal_xmeasuremin(), target);
+  }
+
+  // double xmeasureMax = 2;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_xmeasuremax = this->_internal_xmeasuremax();
+  ::uint64_t raw_xmeasuremax;
+  memcpy(&raw_xmeasuremax, &tmp_xmeasuremax, sizeof(tmp_xmeasuremax));
+  if (raw_xmeasuremax != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        2, this->_internal_xmeasuremax(), target);
+  }
+
+  // double ymeasureMin = 3;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_ymeasuremin = this->_internal_ymeasuremin();
+  ::uint64_t raw_ymeasuremin;
+  memcpy(&raw_ymeasuremin, &tmp_ymeasuremin, sizeof(tmp_ymeasuremin));
+  if (raw_ymeasuremin != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        3, this->_internal_ymeasuremin(), target);
+  }
+
+  // double ymeasureMax = 4;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_ymeasuremax = this->_internal_ymeasuremax();
+  ::uint64_t raw_ymeasuremax;
+  memcpy(&raw_ymeasuremax, &tmp_ymeasuremax, sizeof(tmp_ymeasuremax));
+  if (raw_ymeasuremax != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        4, this->_internal_ymeasuremax(), target);
+  }
+
+  // double xposfix = 5;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_xposfix = this->_internal_xposfix();
+  ::uint64_t raw_xposfix;
+  memcpy(&raw_xposfix, &tmp_xposfix, sizeof(tmp_xposfix));
+  if (raw_xposfix != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        5, this->_internal_xposfix(), target);
+  }
+
+  // double yposfix = 6;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_yposfix = this->_internal_yposfix();
+  ::uint64_t raw_yposfix;
+  memcpy(&raw_yposfix, &tmp_yposfix, sizeof(tmp_yposfix));
+  if (raw_yposfix != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        6, this->_internal_yposfix(), target);
+  }
+
+  // double scanAngle = 7;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_scanangle = this->_internal_scanangle();
+  ::uint64_t raw_scanangle;
+  memcpy(&raw_scanangle, &tmp_scanangle, sizeof(tmp_scanangle));
+  if (raw_scanangle != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        7, this->_internal_scanangle(), target);
+  }
+
+  // double scanAngleMin = 8;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_scananglemin = this->_internal_scananglemin();
+  ::uint64_t raw_scananglemin;
+  memcpy(&raw_scananglemin, &tmp_scananglemin, sizeof(tmp_scananglemin));
+  if (raw_scananglemin != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        8, this->_internal_scananglemin(), target);
+  }
+
+  // double scanAngleMax = 9;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_scananglemax = this->_internal_scananglemax();
+  ::uint64_t raw_scananglemax;
+  memcpy(&raw_scananglemax, &tmp_scananglemax, sizeof(tmp_scananglemax));
+  if (raw_scananglemax != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        9, this->_internal_scananglemax(), target);
+  }
+
+  // double fixAngle = 10;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_fixangle = this->_internal_fixangle();
+  ::uint64_t raw_fixangle;
+  memcpy(&raw_fixangle, &tmp_fixangle, sizeof(tmp_fixangle));
+  if (raw_fixangle != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        10, this->_internal_fixangle(), target);
+  }
+
+  // double fixAngleMin = 11;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_fixanglemin = this->_internal_fixanglemin();
+  ::uint64_t raw_fixanglemin;
+  memcpy(&raw_fixanglemin, &tmp_fixanglemin, sizeof(tmp_fixanglemin));
+  if (raw_fixanglemin != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        11, this->_internal_fixanglemin(), target);
+  }
+
+  // double fixAngleMax = 12;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_fixanglemax = this->_internal_fixanglemax();
+  ::uint64_t raw_fixanglemax;
+  memcpy(&raw_fixanglemax, &tmp_fixanglemax, sizeof(tmp_fixanglemax));
+  if (raw_fixanglemax != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        12, this->_internal_fixanglemax(), target);
+  }
+
+  // double xcorrect = 13;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_xcorrect = this->_internal_xcorrect();
+  ::uint64_t raw_xcorrect;
+  memcpy(&raw_xcorrect, &tmp_xcorrect, sizeof(tmp_xcorrect));
+  if (raw_xcorrect != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        13, this->_internal_xcorrect(), target);
+  }
+
+  // double ycorrect = 14;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_ycorrect = this->_internal_ycorrect();
+  ::uint64_t raw_ycorrect;
+  memcpy(&raw_ycorrect, &tmp_ycorrect, sizeof(tmp_ycorrect));
+  if (raw_ycorrect != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        14, this->_internal_ycorrect(), target);
+  }
+
+  // double xcorrectMin = 15;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_xcorrectmin = this->_internal_xcorrectmin();
+  ::uint64_t raw_xcorrectmin;
+  memcpy(&raw_xcorrectmin, &tmp_xcorrectmin, sizeof(tmp_xcorrectmin));
+  if (raw_xcorrectmin != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        15, this->_internal_xcorrectmin(), target);
+  }
+
+  // double xcorrectMax = 16;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_xcorrectmax = this->_internal_xcorrectmax();
+  ::uint64_t raw_xcorrectmax;
+  memcpy(&raw_xcorrectmax, &tmp_xcorrectmax, sizeof(tmp_xcorrectmax));
+  if (raw_xcorrectmax != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        16, this->_internal_xcorrectmax(), target);
+  }
+
+  // double ycorrectMin = 17;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_ycorrectmin = this->_internal_ycorrectmin();
+  ::uint64_t raw_ycorrectmin;
+  memcpy(&raw_ycorrectmin, &tmp_ycorrectmin, sizeof(tmp_ycorrectmin));
+  if (raw_ycorrectmin != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        17, this->_internal_ycorrectmin(), target);
+  }
+
+  // double ycorrectMax = 18;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_ycorrectmax = this->_internal_ycorrectmax();
+  ::uint64_t raw_ycorrectmax;
+  memcpy(&raw_ycorrectmax, &tmp_ycorrectmax, sizeof(tmp_ycorrectmax));
+  if (raw_ycorrectmax != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        18, this->_internal_ycorrectmax(), target);
+  }
+
+  // double realXOffset = 19;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_realxoffset = this->_internal_realxoffset();
+  ::uint64_t raw_realxoffset;
+  memcpy(&raw_realxoffset, &tmp_realxoffset, sizeof(tmp_realxoffset));
+  if (raw_realxoffset != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        19, this->_internal_realxoffset(), target);
+  }
+
+  // double realYOffset = 20;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_realyoffset = this->_internal_realyoffset();
+  ::uint64_t raw_realyoffset;
+  memcpy(&raw_realyoffset, &tmp_realyoffset, sizeof(tmp_realyoffset));
+  if (raw_realyoffset != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        20, this->_internal_realyoffset(), target);
+  }
+
+  // double factorK = 21;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_factork = this->_internal_factork();
+  ::uint64_t raw_factork;
+  memcpy(&raw_factork, &tmp_factork, sizeof(tmp_factork));
+  if (raw_factork != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        21, this->_internal_factork(), target);
+  }
+
+  // bool isCorrectFile3D = 22;
+  if (this->_internal_iscorrectfile3d() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(
+        22, this->_internal_iscorrectfile3d(), target);
+  }
+
+  // bool isDynamicFocus = 23;
+  if (this->_internal_isdynamicfocus() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(
+        23, this->_internal_isdynamicfocus(), target);
+  }
+
+  // double defocusRatio = 24;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_defocusratio = this->_internal_defocusratio();
+  ::uint64_t raw_defocusratio;
+  memcpy(&raw_defocusratio, &tmp_defocusratio, sizeof(tmp_defocusratio));
+  if (raw_defocusratio != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        24, this->_internal_defocusratio(), target);
+  }
+
+  // double defocusRatioMin = 25;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_defocusratiomin = this->_internal_defocusratiomin();
+  ::uint64_t raw_defocusratiomin;
+  memcpy(&raw_defocusratiomin, &tmp_defocusratiomin, sizeof(tmp_defocusratiomin));
+  if (raw_defocusratiomin != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        25, this->_internal_defocusratiomin(), target);
+  }
+
+  // double defocusRatioMax = 26;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_defocusratiomax = this->_internal_defocusratiomax();
+  ::uint64_t raw_defocusratiomax;
+  memcpy(&raw_defocusratiomax, &tmp_defocusratiomax, sizeof(tmp_defocusratiomax));
+  if (raw_defocusratiomax != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        26, this->_internal_defocusratiomax(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target =
+        ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
+            _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:stream.CorrectParamCfg)
+  return target;
+}
+
+::size_t CorrectParamCfg::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:stream.CorrectParamCfg)
+  ::size_t total_size = 0;
+
+  ::uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // double xmeasureMin = 1;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_xmeasuremin = this->_internal_xmeasuremin();
+  ::uint64_t raw_xmeasuremin;
+  memcpy(&raw_xmeasuremin, &tmp_xmeasuremin, sizeof(tmp_xmeasuremin));
+  if (raw_xmeasuremin != 0) {
+    total_size += 9;
+  }
+
+  // double xmeasureMax = 2;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_xmeasuremax = this->_internal_xmeasuremax();
+  ::uint64_t raw_xmeasuremax;
+  memcpy(&raw_xmeasuremax, &tmp_xmeasuremax, sizeof(tmp_xmeasuremax));
+  if (raw_xmeasuremax != 0) {
+    total_size += 9;
+  }
+
+  // double ymeasureMin = 3;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_ymeasuremin = this->_internal_ymeasuremin();
+  ::uint64_t raw_ymeasuremin;
+  memcpy(&raw_ymeasuremin, &tmp_ymeasuremin, sizeof(tmp_ymeasuremin));
+  if (raw_ymeasuremin != 0) {
+    total_size += 9;
+  }
+
+  // double ymeasureMax = 4;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_ymeasuremax = this->_internal_ymeasuremax();
+  ::uint64_t raw_ymeasuremax;
+  memcpy(&raw_ymeasuremax, &tmp_ymeasuremax, sizeof(tmp_ymeasuremax));
+  if (raw_ymeasuremax != 0) {
+    total_size += 9;
+  }
+
+  // double xposfix = 5;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_xposfix = this->_internal_xposfix();
+  ::uint64_t raw_xposfix;
+  memcpy(&raw_xposfix, &tmp_xposfix, sizeof(tmp_xposfix));
+  if (raw_xposfix != 0) {
+    total_size += 9;
+  }
+
+  // double yposfix = 6;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_yposfix = this->_internal_yposfix();
+  ::uint64_t raw_yposfix;
+  memcpy(&raw_yposfix, &tmp_yposfix, sizeof(tmp_yposfix));
+  if (raw_yposfix != 0) {
+    total_size += 9;
+  }
+
+  // double scanAngle = 7;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_scanangle = this->_internal_scanangle();
+  ::uint64_t raw_scanangle;
+  memcpy(&raw_scanangle, &tmp_scanangle, sizeof(tmp_scanangle));
+  if (raw_scanangle != 0) {
+    total_size += 9;
+  }
+
+  // double scanAngleMin = 8;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_scananglemin = this->_internal_scananglemin();
+  ::uint64_t raw_scananglemin;
+  memcpy(&raw_scananglemin, &tmp_scananglemin, sizeof(tmp_scananglemin));
+  if (raw_scananglemin != 0) {
+    total_size += 9;
+  }
+
+  // double scanAngleMax = 9;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_scananglemax = this->_internal_scananglemax();
+  ::uint64_t raw_scananglemax;
+  memcpy(&raw_scananglemax, &tmp_scananglemax, sizeof(tmp_scananglemax));
+  if (raw_scananglemax != 0) {
+    total_size += 9;
+  }
+
+  // double fixAngle = 10;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_fixangle = this->_internal_fixangle();
+  ::uint64_t raw_fixangle;
+  memcpy(&raw_fixangle, &tmp_fixangle, sizeof(tmp_fixangle));
+  if (raw_fixangle != 0) {
+    total_size += 9;
+  }
+
+  // double fixAngleMin = 11;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_fixanglemin = this->_internal_fixanglemin();
+  ::uint64_t raw_fixanglemin;
+  memcpy(&raw_fixanglemin, &tmp_fixanglemin, sizeof(tmp_fixanglemin));
+  if (raw_fixanglemin != 0) {
+    total_size += 9;
+  }
+
+  // double fixAngleMax = 12;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_fixanglemax = this->_internal_fixanglemax();
+  ::uint64_t raw_fixanglemax;
+  memcpy(&raw_fixanglemax, &tmp_fixanglemax, sizeof(tmp_fixanglemax));
+  if (raw_fixanglemax != 0) {
+    total_size += 9;
+  }
+
+  // double xcorrect = 13;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_xcorrect = this->_internal_xcorrect();
+  ::uint64_t raw_xcorrect;
+  memcpy(&raw_xcorrect, &tmp_xcorrect, sizeof(tmp_xcorrect));
+  if (raw_xcorrect != 0) {
+    total_size += 9;
+  }
+
+  // double ycorrect = 14;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_ycorrect = this->_internal_ycorrect();
+  ::uint64_t raw_ycorrect;
+  memcpy(&raw_ycorrect, &tmp_ycorrect, sizeof(tmp_ycorrect));
+  if (raw_ycorrect != 0) {
+    total_size += 9;
+  }
+
+  // double xcorrectMin = 15;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_xcorrectmin = this->_internal_xcorrectmin();
+  ::uint64_t raw_xcorrectmin;
+  memcpy(&raw_xcorrectmin, &tmp_xcorrectmin, sizeof(tmp_xcorrectmin));
+  if (raw_xcorrectmin != 0) {
+    total_size += 9;
+  }
+
+  // double xcorrectMax = 16;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_xcorrectmax = this->_internal_xcorrectmax();
+  ::uint64_t raw_xcorrectmax;
+  memcpy(&raw_xcorrectmax, &tmp_xcorrectmax, sizeof(tmp_xcorrectmax));
+  if (raw_xcorrectmax != 0) {
+    total_size += 10;
+  }
+
+  // double ycorrectMin = 17;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_ycorrectmin = this->_internal_ycorrectmin();
+  ::uint64_t raw_ycorrectmin;
+  memcpy(&raw_ycorrectmin, &tmp_ycorrectmin, sizeof(tmp_ycorrectmin));
+  if (raw_ycorrectmin != 0) {
+    total_size += 10;
+  }
+
+  // double ycorrectMax = 18;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_ycorrectmax = this->_internal_ycorrectmax();
+  ::uint64_t raw_ycorrectmax;
+  memcpy(&raw_ycorrectmax, &tmp_ycorrectmax, sizeof(tmp_ycorrectmax));
+  if (raw_ycorrectmax != 0) {
+    total_size += 10;
+  }
+
+  // double realXOffset = 19;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_realxoffset = this->_internal_realxoffset();
+  ::uint64_t raw_realxoffset;
+  memcpy(&raw_realxoffset, &tmp_realxoffset, sizeof(tmp_realxoffset));
+  if (raw_realxoffset != 0) {
+    total_size += 10;
+  }
+
+  // double realYOffset = 20;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_realyoffset = this->_internal_realyoffset();
+  ::uint64_t raw_realyoffset;
+  memcpy(&raw_realyoffset, &tmp_realyoffset, sizeof(tmp_realyoffset));
+  if (raw_realyoffset != 0) {
+    total_size += 10;
+  }
+
+  // double factorK = 21;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_factork = this->_internal_factork();
+  ::uint64_t raw_factork;
+  memcpy(&raw_factork, &tmp_factork, sizeof(tmp_factork));
+  if (raw_factork != 0) {
+    total_size += 10;
+  }
+
+  // double defocusRatio = 24;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_defocusratio = this->_internal_defocusratio();
+  ::uint64_t raw_defocusratio;
+  memcpy(&raw_defocusratio, &tmp_defocusratio, sizeof(tmp_defocusratio));
+  if (raw_defocusratio != 0) {
+    total_size += 10;
+  }
+
+  // double defocusRatioMin = 25;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_defocusratiomin = this->_internal_defocusratiomin();
+  ::uint64_t raw_defocusratiomin;
+  memcpy(&raw_defocusratiomin, &tmp_defocusratiomin, sizeof(tmp_defocusratiomin));
+  if (raw_defocusratiomin != 0) {
+    total_size += 10;
+  }
+
+  // double defocusRatioMax = 26;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_defocusratiomax = this->_internal_defocusratiomax();
+  ::uint64_t raw_defocusratiomax;
+  memcpy(&raw_defocusratiomax, &tmp_defocusratiomax, sizeof(tmp_defocusratiomax));
+  if (raw_defocusratiomax != 0) {
+    total_size += 10;
+  }
+
+  // bool isCorrectFile3D = 22;
+  if (this->_internal_iscorrectfile3d() != 0) {
+    total_size += 3;
+  }
+
+  // bool isDynamicFocus = 23;
+  if (this->_internal_isdynamicfocus() != 0) {
+    total_size += 3;
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::google::protobuf::Message::ClassData CorrectParamCfg::_class_data_ = {
+    ::google::protobuf::Message::CopyWithSourceCheck,
+    CorrectParamCfg::MergeImpl
+};
+const ::google::protobuf::Message::ClassData*CorrectParamCfg::GetClassData() const { return &_class_data_; }
+
+
+void CorrectParamCfg::MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg) {
+  auto* const _this = static_cast<CorrectParamCfg*>(&to_msg);
+  auto& from = static_cast<const CorrectParamCfg&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:stream.CorrectParamCfg)
+  ABSL_DCHECK_NE(&from, _this);
+  ::uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_xmeasuremin = from._internal_xmeasuremin();
+  ::uint64_t raw_xmeasuremin;
+  memcpy(&raw_xmeasuremin, &tmp_xmeasuremin, sizeof(tmp_xmeasuremin));
+  if (raw_xmeasuremin != 0) {
+    _this->_internal_set_xmeasuremin(from._internal_xmeasuremin());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_xmeasuremax = from._internal_xmeasuremax();
+  ::uint64_t raw_xmeasuremax;
+  memcpy(&raw_xmeasuremax, &tmp_xmeasuremax, sizeof(tmp_xmeasuremax));
+  if (raw_xmeasuremax != 0) {
+    _this->_internal_set_xmeasuremax(from._internal_xmeasuremax());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_ymeasuremin = from._internal_ymeasuremin();
+  ::uint64_t raw_ymeasuremin;
+  memcpy(&raw_ymeasuremin, &tmp_ymeasuremin, sizeof(tmp_ymeasuremin));
+  if (raw_ymeasuremin != 0) {
+    _this->_internal_set_ymeasuremin(from._internal_ymeasuremin());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_ymeasuremax = from._internal_ymeasuremax();
+  ::uint64_t raw_ymeasuremax;
+  memcpy(&raw_ymeasuremax, &tmp_ymeasuremax, sizeof(tmp_ymeasuremax));
+  if (raw_ymeasuremax != 0) {
+    _this->_internal_set_ymeasuremax(from._internal_ymeasuremax());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_xposfix = from._internal_xposfix();
+  ::uint64_t raw_xposfix;
+  memcpy(&raw_xposfix, &tmp_xposfix, sizeof(tmp_xposfix));
+  if (raw_xposfix != 0) {
+    _this->_internal_set_xposfix(from._internal_xposfix());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_yposfix = from._internal_yposfix();
+  ::uint64_t raw_yposfix;
+  memcpy(&raw_yposfix, &tmp_yposfix, sizeof(tmp_yposfix));
+  if (raw_yposfix != 0) {
+    _this->_internal_set_yposfix(from._internal_yposfix());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_scanangle = from._internal_scanangle();
+  ::uint64_t raw_scanangle;
+  memcpy(&raw_scanangle, &tmp_scanangle, sizeof(tmp_scanangle));
+  if (raw_scanangle != 0) {
+    _this->_internal_set_scanangle(from._internal_scanangle());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_scananglemin = from._internal_scananglemin();
+  ::uint64_t raw_scananglemin;
+  memcpy(&raw_scananglemin, &tmp_scananglemin, sizeof(tmp_scananglemin));
+  if (raw_scananglemin != 0) {
+    _this->_internal_set_scananglemin(from._internal_scananglemin());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_scananglemax = from._internal_scananglemax();
+  ::uint64_t raw_scananglemax;
+  memcpy(&raw_scananglemax, &tmp_scananglemax, sizeof(tmp_scananglemax));
+  if (raw_scananglemax != 0) {
+    _this->_internal_set_scananglemax(from._internal_scananglemax());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_fixangle = from._internal_fixangle();
+  ::uint64_t raw_fixangle;
+  memcpy(&raw_fixangle, &tmp_fixangle, sizeof(tmp_fixangle));
+  if (raw_fixangle != 0) {
+    _this->_internal_set_fixangle(from._internal_fixangle());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_fixanglemin = from._internal_fixanglemin();
+  ::uint64_t raw_fixanglemin;
+  memcpy(&raw_fixanglemin, &tmp_fixanglemin, sizeof(tmp_fixanglemin));
+  if (raw_fixanglemin != 0) {
+    _this->_internal_set_fixanglemin(from._internal_fixanglemin());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_fixanglemax = from._internal_fixanglemax();
+  ::uint64_t raw_fixanglemax;
+  memcpy(&raw_fixanglemax, &tmp_fixanglemax, sizeof(tmp_fixanglemax));
+  if (raw_fixanglemax != 0) {
+    _this->_internal_set_fixanglemax(from._internal_fixanglemax());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_xcorrect = from._internal_xcorrect();
+  ::uint64_t raw_xcorrect;
+  memcpy(&raw_xcorrect, &tmp_xcorrect, sizeof(tmp_xcorrect));
+  if (raw_xcorrect != 0) {
+    _this->_internal_set_xcorrect(from._internal_xcorrect());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_ycorrect = from._internal_ycorrect();
+  ::uint64_t raw_ycorrect;
+  memcpy(&raw_ycorrect, &tmp_ycorrect, sizeof(tmp_ycorrect));
+  if (raw_ycorrect != 0) {
+    _this->_internal_set_ycorrect(from._internal_ycorrect());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_xcorrectmin = from._internal_xcorrectmin();
+  ::uint64_t raw_xcorrectmin;
+  memcpy(&raw_xcorrectmin, &tmp_xcorrectmin, sizeof(tmp_xcorrectmin));
+  if (raw_xcorrectmin != 0) {
+    _this->_internal_set_xcorrectmin(from._internal_xcorrectmin());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_xcorrectmax = from._internal_xcorrectmax();
+  ::uint64_t raw_xcorrectmax;
+  memcpy(&raw_xcorrectmax, &tmp_xcorrectmax, sizeof(tmp_xcorrectmax));
+  if (raw_xcorrectmax != 0) {
+    _this->_internal_set_xcorrectmax(from._internal_xcorrectmax());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_ycorrectmin = from._internal_ycorrectmin();
+  ::uint64_t raw_ycorrectmin;
+  memcpy(&raw_ycorrectmin, &tmp_ycorrectmin, sizeof(tmp_ycorrectmin));
+  if (raw_ycorrectmin != 0) {
+    _this->_internal_set_ycorrectmin(from._internal_ycorrectmin());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_ycorrectmax = from._internal_ycorrectmax();
+  ::uint64_t raw_ycorrectmax;
+  memcpy(&raw_ycorrectmax, &tmp_ycorrectmax, sizeof(tmp_ycorrectmax));
+  if (raw_ycorrectmax != 0) {
+    _this->_internal_set_ycorrectmax(from._internal_ycorrectmax());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_realxoffset = from._internal_realxoffset();
+  ::uint64_t raw_realxoffset;
+  memcpy(&raw_realxoffset, &tmp_realxoffset, sizeof(tmp_realxoffset));
+  if (raw_realxoffset != 0) {
+    _this->_internal_set_realxoffset(from._internal_realxoffset());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_realyoffset = from._internal_realyoffset();
+  ::uint64_t raw_realyoffset;
+  memcpy(&raw_realyoffset, &tmp_realyoffset, sizeof(tmp_realyoffset));
+  if (raw_realyoffset != 0) {
+    _this->_internal_set_realyoffset(from._internal_realyoffset());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_factork = from._internal_factork();
+  ::uint64_t raw_factork;
+  memcpy(&raw_factork, &tmp_factork, sizeof(tmp_factork));
+  if (raw_factork != 0) {
+    _this->_internal_set_factork(from._internal_factork());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_defocusratio = from._internal_defocusratio();
+  ::uint64_t raw_defocusratio;
+  memcpy(&raw_defocusratio, &tmp_defocusratio, sizeof(tmp_defocusratio));
+  if (raw_defocusratio != 0) {
+    _this->_internal_set_defocusratio(from._internal_defocusratio());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_defocusratiomin = from._internal_defocusratiomin();
+  ::uint64_t raw_defocusratiomin;
+  memcpy(&raw_defocusratiomin, &tmp_defocusratiomin, sizeof(tmp_defocusratiomin));
+  if (raw_defocusratiomin != 0) {
+    _this->_internal_set_defocusratiomin(from._internal_defocusratiomin());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_defocusratiomax = from._internal_defocusratiomax();
+  ::uint64_t raw_defocusratiomax;
+  memcpy(&raw_defocusratiomax, &tmp_defocusratiomax, sizeof(tmp_defocusratiomax));
+  if (raw_defocusratiomax != 0) {
+    _this->_internal_set_defocusratiomax(from._internal_defocusratiomax());
+  }
+  if (from._internal_iscorrectfile3d() != 0) {
+    _this->_internal_set_iscorrectfile3d(from._internal_iscorrectfile3d());
+  }
+  if (from._internal_isdynamicfocus() != 0) {
+    _this->_internal_set_isdynamicfocus(from._internal_isdynamicfocus());
+  }
+  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void CorrectParamCfg::CopyFrom(const CorrectParamCfg& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:stream.CorrectParamCfg)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+PROTOBUF_NOINLINE bool CorrectParamCfg::IsInitialized() const {
+  return true;
+}
+
+void CorrectParamCfg::InternalSwap(CorrectParamCfg* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::google::protobuf::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.isdynamicfocus_)
+      + sizeof(CorrectParamCfg::_impl_.isdynamicfocus_)
+      - PROTOBUF_FIELD_OFFSET(CorrectParamCfg, _impl_.xmeasuremin_)>(
+          reinterpret_cast<char*>(&_impl_.xmeasuremin_),
+          reinterpret_cast<char*>(&other->_impl_.xmeasuremin_));
+}
+
+::google::protobuf::Metadata CorrectParamCfg::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_stream_2eproto_getter, &descriptor_table_stream_2eproto_once,
+      file_level_metadata_stream_2eproto[16]);
+}
+// ===================================================================
+
+class ScanTestCfg::_Internal {
+ public:
+};
+
+ScanTestCfg::ScanTestCfg(::google::protobuf::Arena* arena)
+    : ::google::protobuf::Message(arena) {
+  SharedCtor(arena);
+  // @@protoc_insertion_point(arena_constructor:stream.ScanTestCfg)
+}
+ScanTestCfg::ScanTestCfg(const ScanTestCfg& from)
+    : ::google::protobuf::Message(), _impl_(from._impl_) {
+  _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
+      from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:stream.ScanTestCfg)
+}
+inline void ScanTestCfg::SharedCtor(::_pb::Arena* arena) {
+  (void)arena;
+  new (&_impl_) Impl_{
+      decltype(_impl_.debugshape_){0},
+      decltype(_impl_.shapesize_){0},
+      decltype(_impl_.shapesizemin_){0},
+      decltype(_impl_.shape_size_max_){0},
+      decltype(_impl_.laser_power_){0},
+      decltype(_impl_.laser_power_min_){0},
+      decltype(_impl_.defocus_){0},
+      decltype(_impl_.defocus_min_){0},
+      decltype(_impl_.defocus_max_){0},
+      decltype(_impl_.laser_power_max_){0},
+      decltype(_impl_.is_cycle_){false},
+      decltype(_impl_.isautoheatingscanner_){false},
+      decltype(_impl_.cross_x_){0},
+      decltype(_impl_.cross_y_){0},
+      decltype(_impl_.z_distance_){0},
+      decltype(_impl_.autoheatingscannerminutes_){0u},
+      decltype(_impl_.autoheatingscannersize_){0u},
+      decltype(_impl_.autoheatingscannerspeed_){0},
+      decltype(_impl_.mark_test_start_x_){0},
+      decltype(_impl_.mark_test_start_y_){0},
+      decltype(_impl_.mark_test_end_x_){0},
+      decltype(_impl_.mark_test_end_y_){0},
+      /*decltype(_impl_._cached_size_)*/ {},
+  };
+}
+ScanTestCfg::~ScanTestCfg() {
+  // @@protoc_insertion_point(destructor:stream.ScanTestCfg)
+  _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
+  SharedDtor();
+}
+inline void ScanTestCfg::SharedDtor() {
+  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
+}
+void ScanTestCfg::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+PROTOBUF_NOINLINE void ScanTestCfg::Clear() {
+// @@protoc_insertion_point(message_clear_start:stream.ScanTestCfg)
+  ::uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  ::memset(&_impl_.debugshape_, 0, static_cast<::size_t>(
+      reinterpret_cast<char*>(&_impl_.mark_test_end_y_) -
+      reinterpret_cast<char*>(&_impl_.debugshape_)) + sizeof(_impl_.mark_test_end_y_));
+  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
+}
+
+const char* ScanTestCfg::_InternalParse(
+    const char* ptr, ::_pbi::ParseContext* ctx) {
+  ptr = ::_pbi::TcParser::ParseLoop(this, ptr, ctx, &_table_.header);
+  return ptr;
+}
+
+
+PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
+const ::_pbi::TcParseTable<5, 22, 0, 0, 2> ScanTestCfg::_table_ = {
+  {
+    0,  // no _has_bits_
+    0, // no _extensions_
+    22, 248,  // max_field_number, fast_idx_mask
+    offsetof(decltype(_table_), field_lookup_table),
+    4290772992,  // skipmap
+    offsetof(decltype(_table_), field_entries),
+    22,  // num_field_entries
+    0,  // num_aux_entries
+    offsetof(decltype(_table_), field_names),  // no aux_entries
+    &_ScanTestCfg_default_instance_._instance,
+    ::_pbi::TcParser::GenericFallback,  // fallback
+  }, {{
+    {::_pbi::TcParser::MiniParse, {}},
+    // int32 debugShape = 1;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanTestCfg, _impl_.debugshape_), 63>(),
+     {8, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.debugshape_)}},
+    // int32 shapeSize = 2;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanTestCfg, _impl_.shapesize_), 63>(),
+     {16, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.shapesize_)}},
+    // int32 shapeSizeMin = 3;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanTestCfg, _impl_.shapesizemin_), 63>(),
+     {24, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.shapesizemin_)}},
+    // int32 shape_size_max = 4;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanTestCfg, _impl_.shape_size_max_), 63>(),
+     {32, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.shape_size_max_)}},
+    // int32 laser_power = 5;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanTestCfg, _impl_.laser_power_), 63>(),
+     {40, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.laser_power_)}},
+    // int32 laser_power_min = 6;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanTestCfg, _impl_.laser_power_min_), 63>(),
+     {48, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.laser_power_min_)}},
+    // int32 laser_power_max = 7;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ScanTestCfg, _impl_.laser_power_max_), 63>(),
+     {56, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.laser_power_max_)}},
+    // double defocus = 8;
+    {::_pbi::TcParser::FastF64S1,
+     {65, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.defocus_)}},
+    // double defocus_min = 9;
+    {::_pbi::TcParser::FastF64S1,
+     {73, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.defocus_min_)}},
+    // double defocus_max = 10;
+    {::_pbi::TcParser::FastF64S1,
+     {81, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.defocus_max_)}},
+    // bool is_cycle = 11;
+    {::_pbi::TcParser::SingularVarintNoZag1<bool, offsetof(ScanTestCfg, _impl_.is_cycle_), 63>(),
+     {88, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.is_cycle_)}},
+    // double cross_x = 12;
+    {::_pbi::TcParser::FastF64S1,
+     {97, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.cross_x_)}},
+    // double cross_y = 13;
+    {::_pbi::TcParser::FastF64S1,
+     {105, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.cross_y_)}},
+    // double z_distance = 14;
+    {::_pbi::TcParser::FastF64S1,
+     {113, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.z_distance_)}},
+    // bool isAutoHeatingScanner = 15;
+    {::_pbi::TcParser::SingularVarintNoZag1<bool, offsetof(ScanTestCfg, _impl_.isautoheatingscanner_), 63>(),
+     {120, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.isautoheatingscanner_)}},
+    // uint32 autoHeatingScannerMinutes = 16;
+    {::_pbi::TcParser::FastV32S2,
+     {384, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.autoheatingscannerminutes_)}},
+    // uint32 autoHeatingScannerSize = 17;
+    {::_pbi::TcParser::FastV32S2,
+     {392, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.autoheatingscannersize_)}},
+    // double autoHeatingScannerSpeed = 18;
+    {::_pbi::TcParser::FastF64S2,
+     {401, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.autoheatingscannerspeed_)}},
+    // double mark_test_start_x = 19;
+    {::_pbi::TcParser::FastF64S2,
+     {409, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.mark_test_start_x_)}},
+    // double mark_test_start_y = 20;
+    {::_pbi::TcParser::FastF64S2,
+     {417, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.mark_test_start_y_)}},
+    // double mark_test_end_x = 21;
+    {::_pbi::TcParser::FastF64S2,
+     {425, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.mark_test_end_x_)}},
+    // double mark_test_end_y = 22;
+    {::_pbi::TcParser::FastF64S2,
+     {433, 63, 0, PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.mark_test_end_y_)}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+  }}, {{
+    65535, 65535
+  }}, {{
+    // int32 debugShape = 1;
+    {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.debugshape_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt32)},
+    // int32 shapeSize = 2;
+    {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.shapesize_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt32)},
+    // int32 shapeSizeMin = 3;
+    {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.shapesizemin_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt32)},
+    // int32 shape_size_max = 4;
+    {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.shape_size_max_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt32)},
+    // int32 laser_power = 5;
+    {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.laser_power_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt32)},
+    // int32 laser_power_min = 6;
+    {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.laser_power_min_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt32)},
+    // int32 laser_power_max = 7;
+    {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.laser_power_max_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt32)},
+    // double defocus = 8;
+    {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.defocus_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double defocus_min = 9;
+    {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.defocus_min_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double defocus_max = 10;
+    {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.defocus_max_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // bool is_cycle = 11;
+    {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.is_cycle_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kBool)},
+    // double cross_x = 12;
+    {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.cross_x_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double cross_y = 13;
+    {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.cross_y_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double z_distance = 14;
+    {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.z_distance_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // bool isAutoHeatingScanner = 15;
+    {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.isautoheatingscanner_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kBool)},
+    // uint32 autoHeatingScannerMinutes = 16;
+    {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.autoheatingscannerminutes_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kUInt32)},
+    // uint32 autoHeatingScannerSize = 17;
+    {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.autoheatingscannersize_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kUInt32)},
+    // double autoHeatingScannerSpeed = 18;
+    {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.autoheatingscannerspeed_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double mark_test_start_x = 19;
+    {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.mark_test_start_x_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double mark_test_start_y = 20;
+    {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.mark_test_start_y_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double mark_test_end_x = 21;
+    {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.mark_test_end_x_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double mark_test_end_y = 22;
+    {PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.mark_test_end_y_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+  }},
+  // no aux_entries
+  {{
+  }},
+};
+
+::uint8_t* ScanTestCfg::_InternalSerialize(
+    ::uint8_t* target,
+    ::google::protobuf::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:stream.ScanTestCfg)
+  ::uint32_t cached_has_bits = 0;
+  (void)cached_has_bits;
+
+  // int32 debugShape = 1;
+  if (this->_internal_debugshape() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt32ToArrayWithField<1>(
+            stream, this->_internal_debugshape(), target);
+  }
+
+  // int32 shapeSize = 2;
+  if (this->_internal_shapesize() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt32ToArrayWithField<2>(
+            stream, this->_internal_shapesize(), target);
+  }
+
+  // int32 shapeSizeMin = 3;
+  if (this->_internal_shapesizemin() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt32ToArrayWithField<3>(
+            stream, this->_internal_shapesizemin(), target);
+  }
+
+  // int32 shape_size_max = 4;
+  if (this->_internal_shape_size_max() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt32ToArrayWithField<4>(
+            stream, this->_internal_shape_size_max(), target);
+  }
+
+  // int32 laser_power = 5;
+  if (this->_internal_laser_power() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt32ToArrayWithField<5>(
+            stream, this->_internal_laser_power(), target);
+  }
+
+  // int32 laser_power_min = 6;
+  if (this->_internal_laser_power_min() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt32ToArrayWithField<6>(
+            stream, this->_internal_laser_power_min(), target);
+  }
+
+  // int32 laser_power_max = 7;
+  if (this->_internal_laser_power_max() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt32ToArrayWithField<7>(
+            stream, this->_internal_laser_power_max(), target);
+  }
+
+  // double defocus = 8;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_defocus = this->_internal_defocus();
+  ::uint64_t raw_defocus;
+  memcpy(&raw_defocus, &tmp_defocus, sizeof(tmp_defocus));
+  if (raw_defocus != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        8, this->_internal_defocus(), target);
+  }
+
+  // double defocus_min = 9;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_defocus_min = this->_internal_defocus_min();
+  ::uint64_t raw_defocus_min;
+  memcpy(&raw_defocus_min, &tmp_defocus_min, sizeof(tmp_defocus_min));
+  if (raw_defocus_min != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        9, this->_internal_defocus_min(), target);
+  }
+
+  // double defocus_max = 10;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_defocus_max = this->_internal_defocus_max();
+  ::uint64_t raw_defocus_max;
+  memcpy(&raw_defocus_max, &tmp_defocus_max, sizeof(tmp_defocus_max));
+  if (raw_defocus_max != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        10, this->_internal_defocus_max(), target);
+  }
+
+  // bool is_cycle = 11;
+  if (this->_internal_is_cycle() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(
+        11, this->_internal_is_cycle(), target);
+  }
+
+  // double cross_x = 12;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_cross_x = this->_internal_cross_x();
+  ::uint64_t raw_cross_x;
+  memcpy(&raw_cross_x, &tmp_cross_x, sizeof(tmp_cross_x));
+  if (raw_cross_x != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        12, this->_internal_cross_x(), target);
+  }
+
+  // double cross_y = 13;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_cross_y = this->_internal_cross_y();
+  ::uint64_t raw_cross_y;
+  memcpy(&raw_cross_y, &tmp_cross_y, sizeof(tmp_cross_y));
+  if (raw_cross_y != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        13, this->_internal_cross_y(), target);
+  }
+
+  // double z_distance = 14;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_z_distance = this->_internal_z_distance();
+  ::uint64_t raw_z_distance;
+  memcpy(&raw_z_distance, &tmp_z_distance, sizeof(tmp_z_distance));
+  if (raw_z_distance != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        14, this->_internal_z_distance(), target);
+  }
+
+  // bool isAutoHeatingScanner = 15;
+  if (this->_internal_isautoheatingscanner() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(
+        15, this->_internal_isautoheatingscanner(), target);
+  }
+
+  // uint32 autoHeatingScannerMinutes = 16;
+  if (this->_internal_autoheatingscannerminutes() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
+        16, this->_internal_autoheatingscannerminutes(), target);
+  }
+
+  // uint32 autoHeatingScannerSize = 17;
+  if (this->_internal_autoheatingscannersize() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
+        17, this->_internal_autoheatingscannersize(), target);
+  }
+
+  // double autoHeatingScannerSpeed = 18;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_autoheatingscannerspeed = this->_internal_autoheatingscannerspeed();
+  ::uint64_t raw_autoheatingscannerspeed;
+  memcpy(&raw_autoheatingscannerspeed, &tmp_autoheatingscannerspeed, sizeof(tmp_autoheatingscannerspeed));
+  if (raw_autoheatingscannerspeed != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        18, this->_internal_autoheatingscannerspeed(), target);
+  }
+
+  // double mark_test_start_x = 19;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_mark_test_start_x = this->_internal_mark_test_start_x();
+  ::uint64_t raw_mark_test_start_x;
+  memcpy(&raw_mark_test_start_x, &tmp_mark_test_start_x, sizeof(tmp_mark_test_start_x));
+  if (raw_mark_test_start_x != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        19, this->_internal_mark_test_start_x(), target);
+  }
+
+  // double mark_test_start_y = 20;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_mark_test_start_y = this->_internal_mark_test_start_y();
+  ::uint64_t raw_mark_test_start_y;
+  memcpy(&raw_mark_test_start_y, &tmp_mark_test_start_y, sizeof(tmp_mark_test_start_y));
+  if (raw_mark_test_start_y != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        20, this->_internal_mark_test_start_y(), target);
+  }
+
+  // double mark_test_end_x = 21;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_mark_test_end_x = this->_internal_mark_test_end_x();
+  ::uint64_t raw_mark_test_end_x;
+  memcpy(&raw_mark_test_end_x, &tmp_mark_test_end_x, sizeof(tmp_mark_test_end_x));
+  if (raw_mark_test_end_x != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        21, this->_internal_mark_test_end_x(), target);
+  }
+
+  // double mark_test_end_y = 22;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_mark_test_end_y = this->_internal_mark_test_end_y();
+  ::uint64_t raw_mark_test_end_y;
+  memcpy(&raw_mark_test_end_y, &tmp_mark_test_end_y, sizeof(tmp_mark_test_end_y));
+  if (raw_mark_test_end_y != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        22, this->_internal_mark_test_end_y(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target =
+        ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
+            _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:stream.ScanTestCfg)
+  return target;
+}
+
+::size_t ScanTestCfg::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:stream.ScanTestCfg)
+  ::size_t total_size = 0;
+
+  ::uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // int32 debugShape = 1;
+  if (this->_internal_debugshape() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
+        this->_internal_debugshape());
+  }
+
+  // int32 shapeSize = 2;
+  if (this->_internal_shapesize() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
+        this->_internal_shapesize());
+  }
+
+  // int32 shapeSizeMin = 3;
+  if (this->_internal_shapesizemin() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
+        this->_internal_shapesizemin());
+  }
+
+  // int32 shape_size_max = 4;
+  if (this->_internal_shape_size_max() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
+        this->_internal_shape_size_max());
+  }
+
+  // int32 laser_power = 5;
+  if (this->_internal_laser_power() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
+        this->_internal_laser_power());
+  }
+
+  // int32 laser_power_min = 6;
+  if (this->_internal_laser_power_min() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
+        this->_internal_laser_power_min());
+  }
+
+  // double defocus = 8;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_defocus = this->_internal_defocus();
+  ::uint64_t raw_defocus;
+  memcpy(&raw_defocus, &tmp_defocus, sizeof(tmp_defocus));
+  if (raw_defocus != 0) {
+    total_size += 9;
+  }
+
+  // double defocus_min = 9;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_defocus_min = this->_internal_defocus_min();
+  ::uint64_t raw_defocus_min;
+  memcpy(&raw_defocus_min, &tmp_defocus_min, sizeof(tmp_defocus_min));
+  if (raw_defocus_min != 0) {
+    total_size += 9;
+  }
+
+  // double defocus_max = 10;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_defocus_max = this->_internal_defocus_max();
+  ::uint64_t raw_defocus_max;
+  memcpy(&raw_defocus_max, &tmp_defocus_max, sizeof(tmp_defocus_max));
+  if (raw_defocus_max != 0) {
+    total_size += 9;
+  }
+
+  // int32 laser_power_max = 7;
+  if (this->_internal_laser_power_max() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
+        this->_internal_laser_power_max());
+  }
+
+  // bool is_cycle = 11;
+  if (this->_internal_is_cycle() != 0) {
+    total_size += 2;
+  }
+
+  // bool isAutoHeatingScanner = 15;
+  if (this->_internal_isautoheatingscanner() != 0) {
+    total_size += 2;
+  }
+
+  // double cross_x = 12;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_cross_x = this->_internal_cross_x();
+  ::uint64_t raw_cross_x;
+  memcpy(&raw_cross_x, &tmp_cross_x, sizeof(tmp_cross_x));
+  if (raw_cross_x != 0) {
+    total_size += 9;
+  }
+
+  // double cross_y = 13;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_cross_y = this->_internal_cross_y();
+  ::uint64_t raw_cross_y;
+  memcpy(&raw_cross_y, &tmp_cross_y, sizeof(tmp_cross_y));
+  if (raw_cross_y != 0) {
+    total_size += 9;
+  }
+
+  // double z_distance = 14;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_z_distance = this->_internal_z_distance();
+  ::uint64_t raw_z_distance;
+  memcpy(&raw_z_distance, &tmp_z_distance, sizeof(tmp_z_distance));
+  if (raw_z_distance != 0) {
+    total_size += 9;
+  }
+
+  // uint32 autoHeatingScannerMinutes = 16;
+  if (this->_internal_autoheatingscannerminutes() != 0) {
+    total_size += 2 + ::_pbi::WireFormatLite::UInt32Size(
+                                    this->_internal_autoheatingscannerminutes());
+  }
+
+  // uint32 autoHeatingScannerSize = 17;
+  if (this->_internal_autoheatingscannersize() != 0) {
+    total_size += 2 + ::_pbi::WireFormatLite::UInt32Size(
+                                    this->_internal_autoheatingscannersize());
+  }
+
+  // double autoHeatingScannerSpeed = 18;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_autoheatingscannerspeed = this->_internal_autoheatingscannerspeed();
+  ::uint64_t raw_autoheatingscannerspeed;
+  memcpy(&raw_autoheatingscannerspeed, &tmp_autoheatingscannerspeed, sizeof(tmp_autoheatingscannerspeed));
+  if (raw_autoheatingscannerspeed != 0) {
+    total_size += 10;
+  }
+
+  // double mark_test_start_x = 19;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_mark_test_start_x = this->_internal_mark_test_start_x();
+  ::uint64_t raw_mark_test_start_x;
+  memcpy(&raw_mark_test_start_x, &tmp_mark_test_start_x, sizeof(tmp_mark_test_start_x));
+  if (raw_mark_test_start_x != 0) {
+    total_size += 10;
+  }
+
+  // double mark_test_start_y = 20;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_mark_test_start_y = this->_internal_mark_test_start_y();
+  ::uint64_t raw_mark_test_start_y;
+  memcpy(&raw_mark_test_start_y, &tmp_mark_test_start_y, sizeof(tmp_mark_test_start_y));
+  if (raw_mark_test_start_y != 0) {
+    total_size += 10;
+  }
+
+  // double mark_test_end_x = 21;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_mark_test_end_x = this->_internal_mark_test_end_x();
+  ::uint64_t raw_mark_test_end_x;
+  memcpy(&raw_mark_test_end_x, &tmp_mark_test_end_x, sizeof(tmp_mark_test_end_x));
+  if (raw_mark_test_end_x != 0) {
+    total_size += 10;
+  }
+
+  // double mark_test_end_y = 22;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_mark_test_end_y = this->_internal_mark_test_end_y();
+  ::uint64_t raw_mark_test_end_y;
+  memcpy(&raw_mark_test_end_y, &tmp_mark_test_end_y, sizeof(tmp_mark_test_end_y));
+  if (raw_mark_test_end_y != 0) {
+    total_size += 10;
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::google::protobuf::Message::ClassData ScanTestCfg::_class_data_ = {
+    ::google::protobuf::Message::CopyWithSourceCheck,
+    ScanTestCfg::MergeImpl
+};
+const ::google::protobuf::Message::ClassData*ScanTestCfg::GetClassData() const { return &_class_data_; }
+
+
+void ScanTestCfg::MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg) {
+  auto* const _this = static_cast<ScanTestCfg*>(&to_msg);
+  auto& from = static_cast<const ScanTestCfg&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:stream.ScanTestCfg)
+  ABSL_DCHECK_NE(&from, _this);
+  ::uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_debugshape() != 0) {
+    _this->_internal_set_debugshape(from._internal_debugshape());
+  }
+  if (from._internal_shapesize() != 0) {
+    _this->_internal_set_shapesize(from._internal_shapesize());
+  }
+  if (from._internal_shapesizemin() != 0) {
+    _this->_internal_set_shapesizemin(from._internal_shapesizemin());
+  }
+  if (from._internal_shape_size_max() != 0) {
+    _this->_internal_set_shape_size_max(from._internal_shape_size_max());
+  }
+  if (from._internal_laser_power() != 0) {
+    _this->_internal_set_laser_power(from._internal_laser_power());
+  }
+  if (from._internal_laser_power_min() != 0) {
+    _this->_internal_set_laser_power_min(from._internal_laser_power_min());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_defocus = from._internal_defocus();
+  ::uint64_t raw_defocus;
+  memcpy(&raw_defocus, &tmp_defocus, sizeof(tmp_defocus));
+  if (raw_defocus != 0) {
+    _this->_internal_set_defocus(from._internal_defocus());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_defocus_min = from._internal_defocus_min();
+  ::uint64_t raw_defocus_min;
+  memcpy(&raw_defocus_min, &tmp_defocus_min, sizeof(tmp_defocus_min));
+  if (raw_defocus_min != 0) {
+    _this->_internal_set_defocus_min(from._internal_defocus_min());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_defocus_max = from._internal_defocus_max();
+  ::uint64_t raw_defocus_max;
+  memcpy(&raw_defocus_max, &tmp_defocus_max, sizeof(tmp_defocus_max));
+  if (raw_defocus_max != 0) {
+    _this->_internal_set_defocus_max(from._internal_defocus_max());
+  }
+  if (from._internal_laser_power_max() != 0) {
+    _this->_internal_set_laser_power_max(from._internal_laser_power_max());
+  }
+  if (from._internal_is_cycle() != 0) {
+    _this->_internal_set_is_cycle(from._internal_is_cycle());
+  }
+  if (from._internal_isautoheatingscanner() != 0) {
+    _this->_internal_set_isautoheatingscanner(from._internal_isautoheatingscanner());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_cross_x = from._internal_cross_x();
+  ::uint64_t raw_cross_x;
+  memcpy(&raw_cross_x, &tmp_cross_x, sizeof(tmp_cross_x));
+  if (raw_cross_x != 0) {
+    _this->_internal_set_cross_x(from._internal_cross_x());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_cross_y = from._internal_cross_y();
+  ::uint64_t raw_cross_y;
+  memcpy(&raw_cross_y, &tmp_cross_y, sizeof(tmp_cross_y));
+  if (raw_cross_y != 0) {
+    _this->_internal_set_cross_y(from._internal_cross_y());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_z_distance = from._internal_z_distance();
+  ::uint64_t raw_z_distance;
+  memcpy(&raw_z_distance, &tmp_z_distance, sizeof(tmp_z_distance));
+  if (raw_z_distance != 0) {
+    _this->_internal_set_z_distance(from._internal_z_distance());
+  }
+  if (from._internal_autoheatingscannerminutes() != 0) {
+    _this->_internal_set_autoheatingscannerminutes(from._internal_autoheatingscannerminutes());
+  }
+  if (from._internal_autoheatingscannersize() != 0) {
+    _this->_internal_set_autoheatingscannersize(from._internal_autoheatingscannersize());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_autoheatingscannerspeed = from._internal_autoheatingscannerspeed();
+  ::uint64_t raw_autoheatingscannerspeed;
+  memcpy(&raw_autoheatingscannerspeed, &tmp_autoheatingscannerspeed, sizeof(tmp_autoheatingscannerspeed));
+  if (raw_autoheatingscannerspeed != 0) {
+    _this->_internal_set_autoheatingscannerspeed(from._internal_autoheatingscannerspeed());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_mark_test_start_x = from._internal_mark_test_start_x();
+  ::uint64_t raw_mark_test_start_x;
+  memcpy(&raw_mark_test_start_x, &tmp_mark_test_start_x, sizeof(tmp_mark_test_start_x));
+  if (raw_mark_test_start_x != 0) {
+    _this->_internal_set_mark_test_start_x(from._internal_mark_test_start_x());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_mark_test_start_y = from._internal_mark_test_start_y();
+  ::uint64_t raw_mark_test_start_y;
+  memcpy(&raw_mark_test_start_y, &tmp_mark_test_start_y, sizeof(tmp_mark_test_start_y));
+  if (raw_mark_test_start_y != 0) {
+    _this->_internal_set_mark_test_start_y(from._internal_mark_test_start_y());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_mark_test_end_x = from._internal_mark_test_end_x();
+  ::uint64_t raw_mark_test_end_x;
+  memcpy(&raw_mark_test_end_x, &tmp_mark_test_end_x, sizeof(tmp_mark_test_end_x));
+  if (raw_mark_test_end_x != 0) {
+    _this->_internal_set_mark_test_end_x(from._internal_mark_test_end_x());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_mark_test_end_y = from._internal_mark_test_end_y();
+  ::uint64_t raw_mark_test_end_y;
+  memcpy(&raw_mark_test_end_y, &tmp_mark_test_end_y, sizeof(tmp_mark_test_end_y));
+  if (raw_mark_test_end_y != 0) {
+    _this->_internal_set_mark_test_end_y(from._internal_mark_test_end_y());
+  }
+  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ScanTestCfg::CopyFrom(const ScanTestCfg& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:stream.ScanTestCfg)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+PROTOBUF_NOINLINE bool ScanTestCfg::IsInitialized() const {
+  return true;
+}
+
+void ScanTestCfg::InternalSwap(ScanTestCfg* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::google::protobuf::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.mark_test_end_y_)
+      + sizeof(ScanTestCfg::_impl_.mark_test_end_y_)
+      - PROTOBUF_FIELD_OFFSET(ScanTestCfg, _impl_.debugshape_)>(
+          reinterpret_cast<char*>(&_impl_.debugshape_),
+          reinterpret_cast<char*>(&other->_impl_.debugshape_));
+}
+
+::google::protobuf::Metadata ScanTestCfg::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_stream_2eproto_getter, &descriptor_table_stream_2eproto_once,
+      file_level_metadata_stream_2eproto[17]);
+}
+// ===================================================================
+
+class SkyWritingCfg::_Internal {
+ public:
+};
+
+SkyWritingCfg::SkyWritingCfg(::google::protobuf::Arena* arena)
+    : ::google::protobuf::Message(arena) {
+  SharedCtor(arena);
+  // @@protoc_insertion_point(arena_constructor:stream.SkyWritingCfg)
+}
+SkyWritingCfg::SkyWritingCfg(const SkyWritingCfg& from)
+    : ::google::protobuf::Message(), _impl_(from._impl_) {
+  _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
+      from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:stream.SkyWritingCfg)
+}
+inline void SkyWritingCfg::SharedCtor(::_pb::Arena* arena) {
+  (void)arena;
+  new (&_impl_) Impl_{
+      decltype(_impl_.timelag_){0},
+      decltype(_impl_.timelagmin_){0},
+      decltype(_impl_.timelagmax_){0},
+      decltype(_impl_.isenable_){false},
+      decltype(_impl_.nprev_){0u},
+      decltype(_impl_.laseronshift_){::int64_t{0}},
+      decltype(_impl_.laseronshiftmin_){::int64_t{0}},
+      decltype(_impl_.laseronshiftmax_){::int64_t{0}},
+      decltype(_impl_.nprevmin_){0u},
+      decltype(_impl_.nprevmax_){0u},
+      decltype(_impl_.npost_){0u},
+      decltype(_impl_.npostmin_){0u},
+      decltype(_impl_.npostmax_){0u},
+      decltype(_impl_.mode_){0},
+      decltype(_impl_.limite_){0},
+      decltype(_impl_.limitemin_){0},
+      decltype(_impl_.limitemax_){0},
+      /*decltype(_impl_._cached_size_)*/ {},
+  };
+}
+SkyWritingCfg::~SkyWritingCfg() {
+  // @@protoc_insertion_point(destructor:stream.SkyWritingCfg)
+  _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
+  SharedDtor();
+}
+inline void SkyWritingCfg::SharedDtor() {
+  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
+}
+void SkyWritingCfg::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+PROTOBUF_NOINLINE void SkyWritingCfg::Clear() {
+// @@protoc_insertion_point(message_clear_start:stream.SkyWritingCfg)
+  ::uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  ::memset(&_impl_.timelag_, 0, static_cast<::size_t>(
+      reinterpret_cast<char*>(&_impl_.limitemax_) -
+      reinterpret_cast<char*>(&_impl_.timelag_)) + sizeof(_impl_.limitemax_));
+  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
+}
+
+const char* SkyWritingCfg::_InternalParse(
+    const char* ptr, ::_pbi::ParseContext* ctx) {
+  ptr = ::_pbi::TcParser::ParseLoop(this, ptr, ctx, &_table_.header);
+  return ptr;
+}
+
+
+PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
+const ::_pbi::TcParseTable<5, 17, 0, 0, 2> SkyWritingCfg::_table_ = {
+  {
+    0,  // no _has_bits_
+    0, // no _extensions_
+    17, 248,  // max_field_number, fast_idx_mask
+    offsetof(decltype(_table_), field_lookup_table),
+    4294836224,  // skipmap
+    offsetof(decltype(_table_), field_entries),
+    17,  // num_field_entries
+    0,  // num_aux_entries
+    offsetof(decltype(_table_), field_names),  // no aux_entries
+    &_SkyWritingCfg_default_instance_._instance,
+    ::_pbi::TcParser::GenericFallback,  // fallback
+  }, {{
+    {::_pbi::TcParser::MiniParse, {}},
+    // bool isEnable = 1;
+    {::_pbi::TcParser::SingularVarintNoZag1<bool, offsetof(SkyWritingCfg, _impl_.isenable_), 63>(),
+     {8, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.isenable_)}},
+    // double timelag = 2;
+    {::_pbi::TcParser::FastF64S1,
+     {17, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.timelag_)}},
+    // double timelagMin = 3;
+    {::_pbi::TcParser::FastF64S1,
+     {25, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.timelagmin_)}},
+    // double timelagMax = 4;
+    {::_pbi::TcParser::FastF64S1,
+     {33, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.timelagmax_)}},
+    // int64 laserOnShift = 5;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(SkyWritingCfg, _impl_.laseronshift_), 63>(),
+     {40, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.laseronshift_)}},
+    // int64 laserOnShiftMin = 6;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(SkyWritingCfg, _impl_.laseronshiftmin_), 63>(),
+     {48, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.laseronshiftmin_)}},
+    // int64 laserOnShiftMax = 7;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(SkyWritingCfg, _impl_.laseronshiftmax_), 63>(),
+     {56, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.laseronshiftmax_)}},
+    // uint32 nprev = 8;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(SkyWritingCfg, _impl_.nprev_), 63>(),
+     {64, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.nprev_)}},
+    // uint32 nprevMin = 9;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(SkyWritingCfg, _impl_.nprevmin_), 63>(),
+     {72, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.nprevmin_)}},
+    // uint32 nprevMax = 10;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(SkyWritingCfg, _impl_.nprevmax_), 63>(),
+     {80, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.nprevmax_)}},
+    // uint32 npost = 11;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(SkyWritingCfg, _impl_.npost_), 63>(),
+     {88, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.npost_)}},
+    // uint32 npostMin = 12;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(SkyWritingCfg, _impl_.npostmin_), 63>(),
+     {96, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.npostmin_)}},
+    // uint32 npostMax = 13;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(SkyWritingCfg, _impl_.npostmax_), 63>(),
+     {104, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.npostmax_)}},
+    // int32 mode = 14;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(SkyWritingCfg, _impl_.mode_), 63>(),
+     {112, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.mode_)}},
+    // double limite = 15;
+    {::_pbi::TcParser::FastF64S1,
+     {121, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.limite_)}},
+    // double limiteMin = 16;
+    {::_pbi::TcParser::FastF64S2,
+     {385, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.limitemin_)}},
+    // double limiteMax = 17;
+    {::_pbi::TcParser::FastF64S2,
+     {393, 63, 0, PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.limitemax_)}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+  }}, {{
+    65535, 65535
+  }}, {{
+    // bool isEnable = 1;
+    {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.isenable_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kBool)},
+    // double timelag = 2;
+    {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.timelag_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double timelagMin = 3;
+    {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.timelagmin_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double timelagMax = 4;
+    {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.timelagmax_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // int64 laserOnShift = 5;
+    {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.laseronshift_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt64)},
+    // int64 laserOnShiftMin = 6;
+    {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.laseronshiftmin_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt64)},
+    // int64 laserOnShiftMax = 7;
+    {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.laseronshiftmax_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt64)},
+    // uint32 nprev = 8;
+    {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.nprev_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kUInt32)},
+    // uint32 nprevMin = 9;
+    {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.nprevmin_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kUInt32)},
+    // uint32 nprevMax = 10;
+    {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.nprevmax_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kUInt32)},
+    // uint32 npost = 11;
+    {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.npost_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kUInt32)},
+    // uint32 npostMin = 12;
+    {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.npostmin_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kUInt32)},
+    // uint32 npostMax = 13;
+    {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.npostmax_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kUInt32)},
+    // int32 mode = 14;
+    {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.mode_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt32)},
+    // double limite = 15;
+    {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.limite_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double limiteMin = 16;
+    {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.limitemin_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+    // double limiteMax = 17;
+    {PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.limitemax_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
+  }},
+  // no aux_entries
+  {{
+  }},
+};
+
+::uint8_t* SkyWritingCfg::_InternalSerialize(
+    ::uint8_t* target,
+    ::google::protobuf::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:stream.SkyWritingCfg)
+  ::uint32_t cached_has_bits = 0;
+  (void)cached_has_bits;
+
+  // bool isEnable = 1;
+  if (this->_internal_isenable() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(
+        1, this->_internal_isenable(), target);
+  }
+
+  // double timelag = 2;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_timelag = this->_internal_timelag();
+  ::uint64_t raw_timelag;
+  memcpy(&raw_timelag, &tmp_timelag, sizeof(tmp_timelag));
+  if (raw_timelag != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        2, this->_internal_timelag(), target);
+  }
+
+  // double timelagMin = 3;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_timelagmin = this->_internal_timelagmin();
+  ::uint64_t raw_timelagmin;
+  memcpy(&raw_timelagmin, &tmp_timelagmin, sizeof(tmp_timelagmin));
+  if (raw_timelagmin != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        3, this->_internal_timelagmin(), target);
+  }
+
+  // double timelagMax = 4;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_timelagmax = this->_internal_timelagmax();
+  ::uint64_t raw_timelagmax;
+  memcpy(&raw_timelagmax, &tmp_timelagmax, sizeof(tmp_timelagmax));
+  if (raw_timelagmax != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        4, this->_internal_timelagmax(), target);
+  }
+
+  // int64 laserOnShift = 5;
+  if (this->_internal_laseronshift() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt64ToArrayWithField<5>(
+            stream, this->_internal_laseronshift(), target);
+  }
+
+  // int64 laserOnShiftMin = 6;
+  if (this->_internal_laseronshiftmin() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt64ToArrayWithField<6>(
+            stream, this->_internal_laseronshiftmin(), target);
+  }
+
+  // int64 laserOnShiftMax = 7;
+  if (this->_internal_laseronshiftmax() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt64ToArrayWithField<7>(
+            stream, this->_internal_laseronshiftmax(), target);
+  }
+
+  // uint32 nprev = 8;
+  if (this->_internal_nprev() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
+        8, this->_internal_nprev(), target);
+  }
+
+  // uint32 nprevMin = 9;
+  if (this->_internal_nprevmin() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
+        9, this->_internal_nprevmin(), target);
+  }
+
+  // uint32 nprevMax = 10;
+  if (this->_internal_nprevmax() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
+        10, this->_internal_nprevmax(), target);
+  }
+
+  // uint32 npost = 11;
+  if (this->_internal_npost() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
+        11, this->_internal_npost(), target);
+  }
+
+  // uint32 npostMin = 12;
+  if (this->_internal_npostmin() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
+        12, this->_internal_npostmin(), target);
+  }
+
+  // uint32 npostMax = 13;
+  if (this->_internal_npostmax() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
+        13, this->_internal_npostmax(), target);
+  }
+
+  // int32 mode = 14;
+  if (this->_internal_mode() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt32ToArrayWithField<14>(
+            stream, this->_internal_mode(), target);
+  }
+
+  // double limite = 15;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_limite = this->_internal_limite();
+  ::uint64_t raw_limite;
+  memcpy(&raw_limite, &tmp_limite, sizeof(tmp_limite));
+  if (raw_limite != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        15, this->_internal_limite(), target);
+  }
+
+  // double limiteMin = 16;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_limitemin = this->_internal_limitemin();
+  ::uint64_t raw_limitemin;
+  memcpy(&raw_limitemin, &tmp_limitemin, sizeof(tmp_limitemin));
+  if (raw_limitemin != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        16, this->_internal_limitemin(), target);
+  }
+
+  // double limiteMax = 17;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_limitemax = this->_internal_limitemax();
+  ::uint64_t raw_limitemax;
+  memcpy(&raw_limitemax, &tmp_limitemax, sizeof(tmp_limitemax));
+  if (raw_limitemax != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
+        17, this->_internal_limitemax(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target =
+        ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
+            _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:stream.SkyWritingCfg)
+  return target;
+}
+
+::size_t SkyWritingCfg::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:stream.SkyWritingCfg)
+  ::size_t total_size = 0;
+
+  ::uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // double timelag = 2;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_timelag = this->_internal_timelag();
+  ::uint64_t raw_timelag;
+  memcpy(&raw_timelag, &tmp_timelag, sizeof(tmp_timelag));
+  if (raw_timelag != 0) {
+    total_size += 9;
+  }
+
+  // double timelagMin = 3;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_timelagmin = this->_internal_timelagmin();
+  ::uint64_t raw_timelagmin;
+  memcpy(&raw_timelagmin, &tmp_timelagmin, sizeof(tmp_timelagmin));
+  if (raw_timelagmin != 0) {
+    total_size += 9;
+  }
+
+  // double timelagMax = 4;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_timelagmax = this->_internal_timelagmax();
+  ::uint64_t raw_timelagmax;
+  memcpy(&raw_timelagmax, &tmp_timelagmax, sizeof(tmp_timelagmax));
+  if (raw_timelagmax != 0) {
+    total_size += 9;
+  }
+
+  // bool isEnable = 1;
+  if (this->_internal_isenable() != 0) {
+    total_size += 2;
+  }
+
+  // uint32 nprev = 8;
+  if (this->_internal_nprev() != 0) {
+    total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
+        this->_internal_nprev());
+  }
+
+  // int64 laserOnShift = 5;
+  if (this->_internal_laseronshift() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(
+        this->_internal_laseronshift());
+  }
+
+  // int64 laserOnShiftMin = 6;
+  if (this->_internal_laseronshiftmin() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(
+        this->_internal_laseronshiftmin());
+  }
+
+  // int64 laserOnShiftMax = 7;
+  if (this->_internal_laseronshiftmax() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(
+        this->_internal_laseronshiftmax());
+  }
+
+  // uint32 nprevMin = 9;
+  if (this->_internal_nprevmin() != 0) {
+    total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
+        this->_internal_nprevmin());
+  }
+
+  // uint32 nprevMax = 10;
+  if (this->_internal_nprevmax() != 0) {
+    total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
+        this->_internal_nprevmax());
+  }
+
+  // uint32 npost = 11;
+  if (this->_internal_npost() != 0) {
+    total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
+        this->_internal_npost());
+  }
+
+  // uint32 npostMin = 12;
+  if (this->_internal_npostmin() != 0) {
+    total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
+        this->_internal_npostmin());
+  }
+
+  // uint32 npostMax = 13;
+  if (this->_internal_npostmax() != 0) {
+    total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
+        this->_internal_npostmax());
+  }
+
+  // int32 mode = 14;
+  if (this->_internal_mode() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
+        this->_internal_mode());
+  }
+
+  // double limite = 15;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_limite = this->_internal_limite();
+  ::uint64_t raw_limite;
+  memcpy(&raw_limite, &tmp_limite, sizeof(tmp_limite));
+  if (raw_limite != 0) {
+    total_size += 9;
+  }
+
+  // double limiteMin = 16;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_limitemin = this->_internal_limitemin();
+  ::uint64_t raw_limitemin;
+  memcpy(&raw_limitemin, &tmp_limitemin, sizeof(tmp_limitemin));
+  if (raw_limitemin != 0) {
+    total_size += 10;
+  }
+
+  // double limiteMax = 17;
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_limitemax = this->_internal_limitemax();
+  ::uint64_t raw_limitemax;
+  memcpy(&raw_limitemax, &tmp_limitemax, sizeof(tmp_limitemax));
+  if (raw_limitemax != 0) {
+    total_size += 10;
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::google::protobuf::Message::ClassData SkyWritingCfg::_class_data_ = {
+    ::google::protobuf::Message::CopyWithSourceCheck,
+    SkyWritingCfg::MergeImpl
+};
+const ::google::protobuf::Message::ClassData*SkyWritingCfg::GetClassData() const { return &_class_data_; }
+
+
+void SkyWritingCfg::MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg) {
+  auto* const _this = static_cast<SkyWritingCfg*>(&to_msg);
+  auto& from = static_cast<const SkyWritingCfg&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:stream.SkyWritingCfg)
+  ABSL_DCHECK_NE(&from, _this);
+  ::uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_timelag = from._internal_timelag();
+  ::uint64_t raw_timelag;
+  memcpy(&raw_timelag, &tmp_timelag, sizeof(tmp_timelag));
+  if (raw_timelag != 0) {
+    _this->_internal_set_timelag(from._internal_timelag());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_timelagmin = from._internal_timelagmin();
+  ::uint64_t raw_timelagmin;
+  memcpy(&raw_timelagmin, &tmp_timelagmin, sizeof(tmp_timelagmin));
+  if (raw_timelagmin != 0) {
+    _this->_internal_set_timelagmin(from._internal_timelagmin());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_timelagmax = from._internal_timelagmax();
+  ::uint64_t raw_timelagmax;
+  memcpy(&raw_timelagmax, &tmp_timelagmax, sizeof(tmp_timelagmax));
+  if (raw_timelagmax != 0) {
+    _this->_internal_set_timelagmax(from._internal_timelagmax());
+  }
+  if (from._internal_isenable() != 0) {
+    _this->_internal_set_isenable(from._internal_isenable());
+  }
+  if (from._internal_nprev() != 0) {
+    _this->_internal_set_nprev(from._internal_nprev());
+  }
+  if (from._internal_laseronshift() != 0) {
+    _this->_internal_set_laseronshift(from._internal_laseronshift());
+  }
+  if (from._internal_laseronshiftmin() != 0) {
+    _this->_internal_set_laseronshiftmin(from._internal_laseronshiftmin());
+  }
+  if (from._internal_laseronshiftmax() != 0) {
+    _this->_internal_set_laseronshiftmax(from._internal_laseronshiftmax());
+  }
+  if (from._internal_nprevmin() != 0) {
+    _this->_internal_set_nprevmin(from._internal_nprevmin());
+  }
+  if (from._internal_nprevmax() != 0) {
+    _this->_internal_set_nprevmax(from._internal_nprevmax());
+  }
+  if (from._internal_npost() != 0) {
+    _this->_internal_set_npost(from._internal_npost());
+  }
+  if (from._internal_npostmin() != 0) {
+    _this->_internal_set_npostmin(from._internal_npostmin());
+  }
+  if (from._internal_npostmax() != 0) {
+    _this->_internal_set_npostmax(from._internal_npostmax());
+  }
+  if (from._internal_mode() != 0) {
+    _this->_internal_set_mode(from._internal_mode());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_limite = from._internal_limite();
+  ::uint64_t raw_limite;
+  memcpy(&raw_limite, &tmp_limite, sizeof(tmp_limite));
+  if (raw_limite != 0) {
+    _this->_internal_set_limite(from._internal_limite());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_limitemin = from._internal_limitemin();
+  ::uint64_t raw_limitemin;
+  memcpy(&raw_limitemin, &tmp_limitemin, sizeof(tmp_limitemin));
+  if (raw_limitemin != 0) {
+    _this->_internal_set_limitemin(from._internal_limitemin());
+  }
+  static_assert(sizeof(::uint64_t) == sizeof(double),
+                "Code assumes ::uint64_t and double are the same size.");
+  double tmp_limitemax = from._internal_limitemax();
+  ::uint64_t raw_limitemax;
+  memcpy(&raw_limitemax, &tmp_limitemax, sizeof(tmp_limitemax));
+  if (raw_limitemax != 0) {
+    _this->_internal_set_limitemax(from._internal_limitemax());
+  }
+  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SkyWritingCfg::CopyFrom(const SkyWritingCfg& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:stream.SkyWritingCfg)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+PROTOBUF_NOINLINE bool SkyWritingCfg::IsInitialized() const {
+  return true;
+}
+
+void SkyWritingCfg::InternalSwap(SkyWritingCfg* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::google::protobuf::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.limitemax_)
+      + sizeof(SkyWritingCfg::_impl_.limitemax_)
+      - PROTOBUF_FIELD_OFFSET(SkyWritingCfg, _impl_.timelag_)>(
+          reinterpret_cast<char*>(&_impl_.timelag_),
+          reinterpret_cast<char*>(&other->_impl_.timelag_));
+}
+
+::google::protobuf::Metadata SkyWritingCfg::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_stream_2eproto_getter, &descriptor_table_stream_2eproto_once,
+      file_level_metadata_stream_2eproto[18]);
+}
+// ===================================================================
+
+class PowerCompensate::_Internal {
+ public:
+};
+
+PowerCompensate::PowerCompensate(::google::protobuf::Arena* arena)
+    : ::google::protobuf::Message(arena) {
+  SharedCtor(arena);
+  // @@protoc_insertion_point(arena_constructor:stream.PowerCompensate)
+}
+PowerCompensate::PowerCompensate(const PowerCompensate& from)
+    : ::google::protobuf::Message(), _impl_(from._impl_) {
+  _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
+      from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:stream.PowerCompensate)
+}
+inline void PowerCompensate::SharedCtor(::_pb::Arena* arena) {
+  (void)arena;
+  new (&_impl_) Impl_{
+      decltype(_impl_.cno_){0},
+      decltype(_impl_.percent_){0},
+      decltype(_impl_.value_){0},
+      decltype(_impl_.value_min_){0},
+      decltype(_impl_.value_max_){0},
+      /*decltype(_impl_._cached_size_)*/ {},
+  };
+}
+PowerCompensate::~PowerCompensate() {
+  // @@protoc_insertion_point(destructor:stream.PowerCompensate)
+  _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
+  SharedDtor();
+}
+inline void PowerCompensate::SharedDtor() {
+  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
+}
+void PowerCompensate::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+PROTOBUF_NOINLINE void PowerCompensate::Clear() {
+// @@protoc_insertion_point(message_clear_start:stream.PowerCompensate)
+  ::uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  ::memset(&_impl_.cno_, 0, static_cast<::size_t>(
+      reinterpret_cast<char*>(&_impl_.value_max_) -
+      reinterpret_cast<char*>(&_impl_.cno_)) + sizeof(_impl_.value_max_));
+  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
+}
+
+const char* PowerCompensate::_InternalParse(
+    const char* ptr, ::_pbi::ParseContext* ctx) {
+  ptr = ::_pbi::TcParser::ParseLoop(this, ptr, ctx, &_table_.header);
+  return ptr;
+}
+
+
+PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
+const ::_pbi::TcParseTable<3, 5, 0, 0, 2> PowerCompensate::_table_ = {
+  {
+    0,  // no _has_bits_
+    0, // no _extensions_
+    5, 56,  // max_field_number, fast_idx_mask
+    offsetof(decltype(_table_), field_lookup_table),
+    4294967264,  // skipmap
+    offsetof(decltype(_table_), field_entries),
+    5,  // num_field_entries
+    0,  // num_aux_entries
+    offsetof(decltype(_table_), field_names),  // no aux_entries
+    &_PowerCompensate_default_instance_._instance,
+    ::_pbi::TcParser::GenericFallback,  // fallback
+  }, {{
+    {::_pbi::TcParser::MiniParse, {}},
+    // int32 cno = 1;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(PowerCompensate, _impl_.cno_), 63>(),
+     {8, 63, 0, PROTOBUF_FIELD_OFFSET(PowerCompensate, _impl_.cno_)}},
+    // int32 percent = 2;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(PowerCompensate, _impl_.percent_), 63>(),
+     {16, 63, 0, PROTOBUF_FIELD_OFFSET(PowerCompensate, _impl_.percent_)}},
+    // float value = 3;
+    {::_pbi::TcParser::FastF32S1,
+     {29, 63, 0, PROTOBUF_FIELD_OFFSET(PowerCompensate, _impl_.value_)}},
+    // float value_min = 4;
+    {::_pbi::TcParser::FastF32S1,
+     {37, 63, 0, PROTOBUF_FIELD_OFFSET(PowerCompensate, _impl_.value_min_)}},
+    // float value_max = 5;
+    {::_pbi::TcParser::FastF32S1,
+     {45, 63, 0, PROTOBUF_FIELD_OFFSET(PowerCompensate, _impl_.value_max_)}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+  }}, {{
+    65535, 65535
+  }}, {{
+    // int32 cno = 1;
+    {PROTOBUF_FIELD_OFFSET(PowerCompensate, _impl_.cno_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt32)},
+    // int32 percent = 2;
+    {PROTOBUF_FIELD_OFFSET(PowerCompensate, _impl_.percent_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt32)},
+    // float value = 3;
+    {PROTOBUF_FIELD_OFFSET(PowerCompensate, _impl_.value_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kFloat)},
+    // float value_min = 4;
+    {PROTOBUF_FIELD_OFFSET(PowerCompensate, _impl_.value_min_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kFloat)},
+    // float value_max = 5;
+    {PROTOBUF_FIELD_OFFSET(PowerCompensate, _impl_.value_max_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kFloat)},
+  }},
+  // no aux_entries
+  {{
+  }},
+};
+
+::uint8_t* PowerCompensate::_InternalSerialize(
+    ::uint8_t* target,
+    ::google::protobuf::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:stream.PowerCompensate)
+  ::uint32_t cached_has_bits = 0;
+  (void)cached_has_bits;
+
+  // int32 cno = 1;
+  if (this->_internal_cno() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt32ToArrayWithField<1>(
+            stream, this->_internal_cno(), target);
+  }
+
+  // int32 percent = 2;
+  if (this->_internal_percent() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt32ToArrayWithField<2>(
+            stream, this->_internal_percent(), target);
+  }
+
+  // float value = 3;
+  static_assert(sizeof(::uint32_t) == sizeof(float),
+                "Code assumes ::uint32_t and float are the same size.");
+  float tmp_value = this->_internal_value();
+  ::uint32_t raw_value;
+  memcpy(&raw_value, &tmp_value, sizeof(tmp_value));
+  if (raw_value != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteFloatToArray(
+        3, this->_internal_value(), target);
+  }
+
+  // float value_min = 4;
+  static_assert(sizeof(::uint32_t) == sizeof(float),
+                "Code assumes ::uint32_t and float are the same size.");
+  float tmp_value_min = this->_internal_value_min();
+  ::uint32_t raw_value_min;
+  memcpy(&raw_value_min, &tmp_value_min, sizeof(tmp_value_min));
+  if (raw_value_min != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteFloatToArray(
+        4, this->_internal_value_min(), target);
+  }
+
+  // float value_max = 5;
+  static_assert(sizeof(::uint32_t) == sizeof(float),
+                "Code assumes ::uint32_t and float are the same size.");
+  float tmp_value_max = this->_internal_value_max();
+  ::uint32_t raw_value_max;
+  memcpy(&raw_value_max, &tmp_value_max, sizeof(tmp_value_max));
+  if (raw_value_max != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteFloatToArray(
+        5, this->_internal_value_max(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target =
+        ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
+            _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:stream.PowerCompensate)
+  return target;
+}
+
+::size_t PowerCompensate::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:stream.PowerCompensate)
+  ::size_t total_size = 0;
+
+  ::uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // int32 cno = 1;
+  if (this->_internal_cno() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
+        this->_internal_cno());
+  }
+
+  // int32 percent = 2;
+  if (this->_internal_percent() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
+        this->_internal_percent());
+  }
+
+  // float value = 3;
+  static_assert(sizeof(::uint32_t) == sizeof(float),
+                "Code assumes ::uint32_t and float are the same size.");
+  float tmp_value = this->_internal_value();
+  ::uint32_t raw_value;
+  memcpy(&raw_value, &tmp_value, sizeof(tmp_value));
+  if (raw_value != 0) {
+    total_size += 5;
+  }
+
+  // float value_min = 4;
+  static_assert(sizeof(::uint32_t) == sizeof(float),
+                "Code assumes ::uint32_t and float are the same size.");
+  float tmp_value_min = this->_internal_value_min();
+  ::uint32_t raw_value_min;
+  memcpy(&raw_value_min, &tmp_value_min, sizeof(tmp_value_min));
+  if (raw_value_min != 0) {
+    total_size += 5;
+  }
+
+  // float value_max = 5;
+  static_assert(sizeof(::uint32_t) == sizeof(float),
+                "Code assumes ::uint32_t and float are the same size.");
+  float tmp_value_max = this->_internal_value_max();
+  ::uint32_t raw_value_max;
+  memcpy(&raw_value_max, &tmp_value_max, sizeof(tmp_value_max));
+  if (raw_value_max != 0) {
+    total_size += 5;
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::google::protobuf::Message::ClassData PowerCompensate::_class_data_ = {
+    ::google::protobuf::Message::CopyWithSourceCheck,
+    PowerCompensate::MergeImpl
+};
+const ::google::protobuf::Message::ClassData*PowerCompensate::GetClassData() const { return &_class_data_; }
+
+
+void PowerCompensate::MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg) {
+  auto* const _this = static_cast<PowerCompensate*>(&to_msg);
+  auto& from = static_cast<const PowerCompensate&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:stream.PowerCompensate)
+  ABSL_DCHECK_NE(&from, _this);
+  ::uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_cno() != 0) {
+    _this->_internal_set_cno(from._internal_cno());
+  }
+  if (from._internal_percent() != 0) {
+    _this->_internal_set_percent(from._internal_percent());
+  }
+  static_assert(sizeof(::uint32_t) == sizeof(float),
+                "Code assumes ::uint32_t and float are the same size.");
+  float tmp_value = from._internal_value();
+  ::uint32_t raw_value;
+  memcpy(&raw_value, &tmp_value, sizeof(tmp_value));
+  if (raw_value != 0) {
+    _this->_internal_set_value(from._internal_value());
+  }
+  static_assert(sizeof(::uint32_t) == sizeof(float),
+                "Code assumes ::uint32_t and float are the same size.");
+  float tmp_value_min = from._internal_value_min();
+  ::uint32_t raw_value_min;
+  memcpy(&raw_value_min, &tmp_value_min, sizeof(tmp_value_min));
+  if (raw_value_min != 0) {
+    _this->_internal_set_value_min(from._internal_value_min());
+  }
+  static_assert(sizeof(::uint32_t) == sizeof(float),
+                "Code assumes ::uint32_t and float are the same size.");
+  float tmp_value_max = from._internal_value_max();
+  ::uint32_t raw_value_max;
+  memcpy(&raw_value_max, &tmp_value_max, sizeof(tmp_value_max));
+  if (raw_value_max != 0) {
+    _this->_internal_set_value_max(from._internal_value_max());
+  }
+  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void PowerCompensate::CopyFrom(const PowerCompensate& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:stream.PowerCompensate)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+PROTOBUF_NOINLINE bool PowerCompensate::IsInitialized() const {
+  return true;
+}
+
+void PowerCompensate::InternalSwap(PowerCompensate* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::google::protobuf::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(PowerCompensate, _impl_.value_max_)
+      + sizeof(PowerCompensate::_impl_.value_max_)
+      - PROTOBUF_FIELD_OFFSET(PowerCompensate, _impl_.cno_)>(
+          reinterpret_cast<char*>(&_impl_.cno_),
+          reinterpret_cast<char*>(&other->_impl_.cno_));
+}
+
+::google::protobuf::Metadata PowerCompensate::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_stream_2eproto_getter, &descriptor_table_stream_2eproto_once,
+      file_level_metadata_stream_2eproto[19]);
+}
+// ===================================================================
+
+class TimePowerCompensate::_Internal {
+ public:
+};
+
+TimePowerCompensate::TimePowerCompensate(::google::protobuf::Arena* arena)
+    : ::google::protobuf::Message(arena) {
+  SharedCtor(arena);
+  // @@protoc_insertion_point(arena_constructor:stream.TimePowerCompensate)
+}
+TimePowerCompensate::TimePowerCompensate(const TimePowerCompensate& from)
+    : ::google::protobuf::Message(), _impl_(from._impl_) {
+  _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
+      from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:stream.TimePowerCompensate)
+}
+inline void TimePowerCompensate::SharedCtor(::_pb::Arena* arena) {
+  (void)arena;
+  new (&_impl_) Impl_{
+      decltype(_impl_.id_){0},
+      decltype(_impl_.cno_){0},
+      decltype(_impl_.startminute_){0u},
+      decltype(_impl_.endminute_){0u},
+      decltype(_impl_.compensate_){0},
+      /*decltype(_impl_._cached_size_)*/ {},
+  };
+}
+TimePowerCompensate::~TimePowerCompensate() {
+  // @@protoc_insertion_point(destructor:stream.TimePowerCompensate)
+  _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
+  SharedDtor();
+}
+inline void TimePowerCompensate::SharedDtor() {
+  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
+}
+void TimePowerCompensate::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+PROTOBUF_NOINLINE void TimePowerCompensate::Clear() {
+// @@protoc_insertion_point(message_clear_start:stream.TimePowerCompensate)
+  ::uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  ::memset(&_impl_.id_, 0, static_cast<::size_t>(
+      reinterpret_cast<char*>(&_impl_.compensate_) -
+      reinterpret_cast<char*>(&_impl_.id_)) + sizeof(_impl_.compensate_));
+  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
+}
+
+const char* TimePowerCompensate::_InternalParse(
+    const char* ptr, ::_pbi::ParseContext* ctx) {
+  ptr = ::_pbi::TcParser::ParseLoop(this, ptr, ctx, &_table_.header);
+  return ptr;
+}
+
+
+PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
+const ::_pbi::TcParseTable<3, 5, 0, 0, 2> TimePowerCompensate::_table_ = {
+  {
+    0,  // no _has_bits_
+    0, // no _extensions_
+    5, 56,  // max_field_number, fast_idx_mask
+    offsetof(decltype(_table_), field_lookup_table),
+    4294967264,  // skipmap
+    offsetof(decltype(_table_), field_entries),
+    5,  // num_field_entries
+    0,  // num_aux_entries
+    offsetof(decltype(_table_), field_names),  // no aux_entries
+    &_TimePowerCompensate_default_instance_._instance,
+    ::_pbi::TcParser::GenericFallback,  // fallback
+  }, {{
+    {::_pbi::TcParser::MiniParse, {}},
+    // int32 id = 1;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(TimePowerCompensate, _impl_.id_), 63>(),
+     {8, 63, 0, PROTOBUF_FIELD_OFFSET(TimePowerCompensate, _impl_.id_)}},
+    // int32 cno = 2;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(TimePowerCompensate, _impl_.cno_), 63>(),
+     {16, 63, 0, PROTOBUF_FIELD_OFFSET(TimePowerCompensate, _impl_.cno_)}},
+    // uint32 startMinute = 3;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(TimePowerCompensate, _impl_.startminute_), 63>(),
+     {24, 63, 0, PROTOBUF_FIELD_OFFSET(TimePowerCompensate, _impl_.startminute_)}},
+    // uint32 endMinute = 4;
+    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(TimePowerCompensate, _impl_.endminute_), 63>(),
+     {32, 63, 0, PROTOBUF_FIELD_OFFSET(TimePowerCompensate, _impl_.endminute_)}},
+    // float compensate = 5;
+    {::_pbi::TcParser::FastF32S1,
+     {45, 63, 0, PROTOBUF_FIELD_OFFSET(TimePowerCompensate, _impl_.compensate_)}},
+    {::_pbi::TcParser::MiniParse, {}},
+    {::_pbi::TcParser::MiniParse, {}},
+  }}, {{
+    65535, 65535
+  }}, {{
+    // int32 id = 1;
+    {PROTOBUF_FIELD_OFFSET(TimePowerCompensate, _impl_.id_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt32)},
+    // int32 cno = 2;
+    {PROTOBUF_FIELD_OFFSET(TimePowerCompensate, _impl_.cno_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kInt32)},
+    // uint32 startMinute = 3;
+    {PROTOBUF_FIELD_OFFSET(TimePowerCompensate, _impl_.startminute_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kUInt32)},
+    // uint32 endMinute = 4;
+    {PROTOBUF_FIELD_OFFSET(TimePowerCompensate, _impl_.endminute_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kUInt32)},
+    // float compensate = 5;
+    {PROTOBUF_FIELD_OFFSET(TimePowerCompensate, _impl_.compensate_), 0, 0,
+    (0 | ::_fl::kFcSingular | ::_fl::kFloat)},
+  }},
+  // no aux_entries
+  {{
+  }},
+};
+
+::uint8_t* TimePowerCompensate::_InternalSerialize(
+    ::uint8_t* target,
+    ::google::protobuf::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:stream.TimePowerCompensate)
+  ::uint32_t cached_has_bits = 0;
+  (void)cached_has_bits;
+
+  // int32 id = 1;
+  if (this->_internal_id() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt32ToArrayWithField<1>(
+            stream, this->_internal_id(), target);
+  }
+
+  // int32 cno = 2;
+  if (this->_internal_cno() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::
+        WriteInt32ToArrayWithField<2>(
+            stream, this->_internal_cno(), target);
+  }
+
+  // uint32 startMinute = 3;
+  if (this->_internal_startminute() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
+        3, this->_internal_startminute(), target);
+  }
+
+  // uint32 endMinute = 4;
+  if (this->_internal_endminute() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
+        4, this->_internal_endminute(), target);
+  }
+
+  // float compensate = 5;
+  static_assert(sizeof(::uint32_t) == sizeof(float),
+                "Code assumes ::uint32_t and float are the same size.");
+  float tmp_compensate = this->_internal_compensate();
+  ::uint32_t raw_compensate;
+  memcpy(&raw_compensate, &tmp_compensate, sizeof(tmp_compensate));
+  if (raw_compensate != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteFloatToArray(
+        5, this->_internal_compensate(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target =
+        ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
+            _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:stream.TimePowerCompensate)
+  return target;
+}
+
+::size_t TimePowerCompensate::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:stream.TimePowerCompensate)
+  ::size_t total_size = 0;
+
+  ::uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // int32 id = 1;
+  if (this->_internal_id() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
+        this->_internal_id());
+  }
+
+  // int32 cno = 2;
+  if (this->_internal_cno() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
+        this->_internal_cno());
+  }
+
+  // uint32 startMinute = 3;
+  if (this->_internal_startminute() != 0) {
+    total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
+        this->_internal_startminute());
+  }
+
+  // uint32 endMinute = 4;
+  if (this->_internal_endminute() != 0) {
+    total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
+        this->_internal_endminute());
+  }
+
+  // float compensate = 5;
+  static_assert(sizeof(::uint32_t) == sizeof(float),
+                "Code assumes ::uint32_t and float are the same size.");
+  float tmp_compensate = this->_internal_compensate();
+  ::uint32_t raw_compensate;
+  memcpy(&raw_compensate, &tmp_compensate, sizeof(tmp_compensate));
+  if (raw_compensate != 0) {
+    total_size += 5;
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::google::protobuf::Message::ClassData TimePowerCompensate::_class_data_ = {
+    ::google::protobuf::Message::CopyWithSourceCheck,
+    TimePowerCompensate::MergeImpl
+};
+const ::google::protobuf::Message::ClassData*TimePowerCompensate::GetClassData() const { return &_class_data_; }
+
+
+void TimePowerCompensate::MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg) {
+  auto* const _this = static_cast<TimePowerCompensate*>(&to_msg);
+  auto& from = static_cast<const TimePowerCompensate&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:stream.TimePowerCompensate)
+  ABSL_DCHECK_NE(&from, _this);
+  ::uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_id() != 0) {
+    _this->_internal_set_id(from._internal_id());
+  }
+  if (from._internal_cno() != 0) {
+    _this->_internal_set_cno(from._internal_cno());
+  }
+  if (from._internal_startminute() != 0) {
+    _this->_internal_set_startminute(from._internal_startminute());
+  }
+  if (from._internal_endminute() != 0) {
+    _this->_internal_set_endminute(from._internal_endminute());
+  }
+  static_assert(sizeof(::uint32_t) == sizeof(float),
+                "Code assumes ::uint32_t and float are the same size.");
+  float tmp_compensate = from._internal_compensate();
+  ::uint32_t raw_compensate;
+  memcpy(&raw_compensate, &tmp_compensate, sizeof(tmp_compensate));
+  if (raw_compensate != 0) {
+    _this->_internal_set_compensate(from._internal_compensate());
+  }
+  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void TimePowerCompensate::CopyFrom(const TimePowerCompensate& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:stream.TimePowerCompensate)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+PROTOBUF_NOINLINE bool TimePowerCompensate::IsInitialized() const {
+  return true;
+}
+
+void TimePowerCompensate::InternalSwap(TimePowerCompensate* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::google::protobuf::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(TimePowerCompensate, _impl_.compensate_)
+      + sizeof(TimePowerCompensate::_impl_.compensate_)
+      - PROTOBUF_FIELD_OFFSET(TimePowerCompensate, _impl_.id_)>(
+          reinterpret_cast<char*>(&_impl_.id_),
+          reinterpret_cast<char*>(&other->_impl_.id_));
+}
+
+::google::protobuf::Metadata TimePowerCompensate::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_stream_2eproto_getter, &descriptor_table_stream_2eproto_once,
+      file_level_metadata_stream_2eproto[20]);
+}
 // @@protoc_insertion_point(namespace_scope)
 }  // namespace stream
 namespace google {
diff --git a/TestClient/protobuf/stream.pb.h b/TestClient/protobuf/stream.pb.h
index 4fd7990..f1a7c96 100644
--- a/TestClient/protobuf/stream.pb.h
+++ b/TestClient/protobuf/stream.pb.h
@@ -62,6 +62,12 @@ extern ChainDataBlockDefaultTypeInternal _ChainDataBlock_default_instance_;
 class ComResponce;
 struct ComResponceDefaultTypeInternal;
 extern ComResponceDefaultTypeInternal _ComResponce_default_instance_;
+class CorrectParamCfg;
+struct CorrectParamCfgDefaultTypeInternal;
+extern CorrectParamCfgDefaultTypeInternal _CorrectParamCfg_default_instance_;
+class FixPointData;
+struct FixPointDataDefaultTypeInternal;
+extern FixPointDataDefaultTypeInternal _FixPointData_default_instance_;
 class ImgInfoResponce;
 struct ImgInfoResponceDefaultTypeInternal;
 extern ImgInfoResponceDefaultTypeInternal _ImgInfoResponce_default_instance_;
@@ -77,6 +83,9 @@ extern ParamInfoDefaultTypeInternal _ParamInfo_default_instance_;
 class Point;
 struct PointDefaultTypeInternal;
 extern PointDefaultTypeInternal _Point_default_instance_;
+class PowerCompensate;
+struct PowerCompensateDefaultTypeInternal;
+extern PowerCompensateDefaultTypeInternal _PowerCompensate_default_instance_;
 class RegResponce;
 struct RegResponceDefaultTypeInternal;
 extern RegResponceDefaultTypeInternal _RegResponce_default_instance_;
@@ -89,6 +98,24 @@ extern ResponseAnyDefaultTypeInternal _ResponseAny_default_instance_;
 class ResponseInfo;
 struct ResponseInfoDefaultTypeInternal;
 extern ResponseInfoDefaultTypeInternal _ResponseInfo_default_instance_;
+class ScanParamCfg;
+struct ScanParamCfgDefaultTypeInternal;
+extern ScanParamCfgDefaultTypeInternal _ScanParamCfg_default_instance_;
+class ScanTestCfg;
+struct ScanTestCfgDefaultTypeInternal;
+extern ScanTestCfgDefaultTypeInternal _ScanTestCfg_default_instance_;
+class ScannerCrtlCfgData;
+struct ScannerCrtlCfgDataDefaultTypeInternal;
+extern ScannerCrtlCfgDataDefaultTypeInternal _ScannerCrtlCfgData_default_instance_;
+class ScannerCrtlCfgResp;
+struct ScannerCrtlCfgRespDefaultTypeInternal;
+extern ScannerCrtlCfgRespDefaultTypeInternal _ScannerCrtlCfgResp_default_instance_;
+class SkyWritingCfg;
+struct SkyWritingCfgDefaultTypeInternal;
+extern SkyWritingCfgDefaultTypeInternal _SkyWritingCfg_default_instance_;
+class TimePowerCompensate;
+struct TimePowerCompensateDefaultTypeInternal;
+extern TimePowerCompensateDefaultTypeInternal _TimePowerCompensate_default_instance_;
 class VectorDataBlock;
 struct VectorDataBlockDefaultTypeInternal;
 extern VectorDataBlockDefaultTypeInternal _VectorDataBlock_default_instance_;
@@ -311,13 +338,21 @@ class ParamInfo final :
     kNameKeyFieldNumber = 1,
     kStrValueFieldNumber = 2,
     kContextFieldNumber = 4,
+    kCardNameFieldNumber = 15,
+    kCardIPFieldNumber = 16,
     kValueTypeFieldNumber = 3,
+    kStartLayerFieldNumber = 8,
     kIsEnableFieldNumber = 5,
     kIsAlarmFieldNumber = 6,
     kIsShowFieldNumber = 7,
-    kStartLayerFieldNumber = 8,
+    kHadAssignFieldNumber = 17,
     kEndLayerFieldNumber = 9,
     kPowderFieldNumber = 10,
+    kSeqNoFieldNumber = 11,
+    kControlNoFieldNumber = 12,
+    kSerialNoFieldNumber = 13,
+    kControlTypeFieldNumber = 14,
+    kHadMatchFieldNumber = 18,
   };
   // bytes nameKey = 1;
   void clear_namekey() ;
@@ -366,6 +401,38 @@ class ParamInfo final :
       const std::string& value);
   std::string* _internal_mutable_context();
 
+  public:
+  // bytes cardName = 15;
+  void clear_cardname() ;
+  const std::string& cardname() const;
+  template <typename Arg_ = const std::string&, typename... Args_>
+  void set_cardname(Arg_&& arg, Args_... args);
+  std::string* mutable_cardname();
+  PROTOBUF_NODISCARD std::string* release_cardname();
+  void set_allocated_cardname(std::string* ptr);
+
+  private:
+  const std::string& _internal_cardname() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_cardname(
+      const std::string& value);
+  std::string* _internal_mutable_cardname();
+
+  public:
+  // bytes cardIP = 16;
+  void clear_cardip() ;
+  const std::string& cardip() const;
+  template <typename Arg_ = const std::string&, typename... Args_>
+  void set_cardip(Arg_&& arg, Args_... args);
+  std::string* mutable_cardip();
+  PROTOBUF_NODISCARD std::string* release_cardip();
+  void set_allocated_cardip(std::string* ptr);
+
+  private:
+  const std::string& _internal_cardip() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_cardip(
+      const std::string& value);
+  std::string* _internal_mutable_cardip();
+
   public:
   // .stream.TYPE valueType = 3;
   void clear_valuetype() ;
@@ -376,6 +443,16 @@ class ParamInfo final :
   ::stream::TYPE _internal_valuetype() const;
   void _internal_set_valuetype(::stream::TYPE value);
 
+  public:
+  // int32 startLayer = 8;
+  void clear_startlayer() ;
+  ::int32_t startlayer() const;
+  void set_startlayer(::int32_t value);
+
+  private:
+  ::int32_t _internal_startlayer() const;
+  void _internal_set_startlayer(::int32_t value);
+
   public:
   // bool isEnable = 5;
   void clear_isenable() ;
@@ -407,14 +484,14 @@ class ParamInfo final :
   void _internal_set_isshow(bool value);
 
   public:
-  // int32 startLayer = 8;
-  void clear_startlayer() ;
-  ::int32_t startlayer() const;
-  void set_startlayer(::int32_t value);
+  // bool hadAssign = 17;
+  void clear_hadassign() ;
+  bool hadassign() const;
+  void set_hadassign(bool value);
 
   private:
-  ::int32_t _internal_startlayer() const;
-  void _internal_set_startlayer(::int32_t value);
+  bool _internal_hadassign() const;
+  void _internal_set_hadassign(bool value);
 
   public:
   // int32 endLayer = 9;
@@ -436,13 +513,63 @@ class ParamInfo final :
   float _internal_powder() const;
   void _internal_set_powder(float value);
 
+  public:
+  // int32 seqNo = 11;
+  void clear_seqno() ;
+  ::int32_t seqno() const;
+  void set_seqno(::int32_t value);
+
+  private:
+  ::int32_t _internal_seqno() const;
+  void _internal_set_seqno(::int32_t value);
+
+  public:
+  // int32 controlNo = 12;
+  void clear_controlno() ;
+  ::int32_t controlno() const;
+  void set_controlno(::int32_t value);
+
+  private:
+  ::int32_t _internal_controlno() const;
+  void _internal_set_controlno(::int32_t value);
+
+  public:
+  // int32 serialNo = 13;
+  void clear_serialno() ;
+  ::int32_t serialno() const;
+  void set_serialno(::int32_t value);
+
+  private:
+  ::int32_t _internal_serialno() const;
+  void _internal_set_serialno(::int32_t value);
+
+  public:
+  // int32 controlType = 14;
+  void clear_controltype() ;
+  ::int32_t controltype() const;
+  void set_controltype(::int32_t value);
+
+  private:
+  ::int32_t _internal_controltype() const;
+  void _internal_set_controltype(::int32_t value);
+
+  public:
+  // bool hadMatch = 18;
+  void clear_hadmatch() ;
+  bool hadmatch() const;
+  void set_hadmatch(bool value);
+
+  private:
+  bool _internal_hadmatch() const;
+  void _internal_set_hadmatch(bool value);
+
   public:
   // @@protoc_insertion_point(class_scope:stream.ParamInfo)
  private:
   class _Internal;
 
   friend class ::google::protobuf::internal::TcParser;
-  static const ::google::protobuf::internal::TcParseTable<4, 10, 0, 0, 2> _table_;
+  static const ::google::protobuf::internal::TcParseTable<5, 18, 0, 0, 2> _table_;
   template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
   typedef void InternalArenaConstructable_;
   typedef void DestructorSkippable_;
@@ -450,13 +577,21 @@ class ParamInfo final :
     ::google::protobuf::internal::ArenaStringPtr namekey_;
     ::google::protobuf::internal::ArenaStringPtr strvalue_;
     ::google::protobuf::internal::ArenaStringPtr context_;
+    ::google::protobuf::internal::ArenaStringPtr cardname_;
+    ::google::protobuf::internal::ArenaStringPtr cardip_;
     int valuetype_;
+    ::int32_t startlayer_;
     bool isenable_;
     bool isalarm_;
     bool isshow_;
-    ::int32_t startlayer_;
+    bool hadassign_;
     ::int32_t endlayer_;
     float powder_;
+    ::int32_t seqno_;
+    ::int32_t controlno_;
+    ::int32_t serialno_;
+    ::int32_t controltype_;
+    bool hadmatch_;
     mutable ::google::protobuf::internal::CachedSize _cached_size_;
     PROTOBUF_TSAN_DECLARE_MEMBER
   };
@@ -2548,6 +2683,2960 @@ class ComResponce final :
   };
   union { Impl_ _impl_; };
   friend struct ::TableStruct_stream_2eproto;
+};// -------------------------------------------------------------------
+
+class ScannerCrtlCfgResp final :
+    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:stream.ScannerCrtlCfgResp) */ {
+ public:
+  inline ScannerCrtlCfgResp() : ScannerCrtlCfgResp(nullptr) {}
+  ~ScannerCrtlCfgResp() override;
+  template<typename = void>
+  explicit PROTOBUF_CONSTEXPR ScannerCrtlCfgResp(::google::protobuf::internal::ConstantInitialized);
+
+  ScannerCrtlCfgResp(const ScannerCrtlCfgResp& from);
+  ScannerCrtlCfgResp(ScannerCrtlCfgResp&& from) noexcept
+    : ScannerCrtlCfgResp() {
+    *this = ::std::move(from);
+  }
+
+  inline ScannerCrtlCfgResp& operator=(const ScannerCrtlCfgResp& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ScannerCrtlCfgResp& operator=(ScannerCrtlCfgResp&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
+  }
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::google::protobuf::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::google::protobuf::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ScannerCrtlCfgResp& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ScannerCrtlCfgResp* internal_default_instance() {
+    return reinterpret_cast<const ScannerCrtlCfgResp*>(
+               &_ScannerCrtlCfgResp_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    12;
+
+  friend void swap(ScannerCrtlCfgResp& a, ScannerCrtlCfgResp& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ScannerCrtlCfgResp* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::google::protobuf::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ScannerCrtlCfgResp* other) {
+    if (other == this) return;
+    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ScannerCrtlCfgResp* New(::google::protobuf::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ScannerCrtlCfgResp>(arena);
+  }
+  using ::google::protobuf::Message::CopyFrom;
+  void CopyFrom(const ScannerCrtlCfgResp& from);
+  using ::google::protobuf::Message::MergeFrom;
+  void MergeFrom( const ScannerCrtlCfgResp& from) {
+    ScannerCrtlCfgResp::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  ::size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
+  ::uint8_t* _InternalSerialize(
+      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::google::protobuf::Arena* arena);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ScannerCrtlCfgResp* other);
+
+  private:
+  friend class ::google::protobuf::internal::AnyMetadata;
+  static ::absl::string_view FullMessageName() {
+    return "stream.ScannerCrtlCfgResp";
+  }
+  protected:
+  explicit ScannerCrtlCfgResp(::google::protobuf::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::google::protobuf::Message::ClassData*GetClassData() const final;
+
+  ::google::protobuf::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kScannerCfgFieldNumber = 1,
+  };
+  // repeated .stream.ScannerCrtlCfgData scannerCfg = 1;
+  int scannercfg_size() const;
+  private:
+  int _internal_scannercfg_size() const;
+
+  public:
+  void clear_scannercfg() ;
+  ::stream::ScannerCrtlCfgData* mutable_scannercfg(int index);
+  ::google::protobuf::RepeatedPtrField< ::stream::ScannerCrtlCfgData >*
+      mutable_scannercfg();
+  private:
+  const ::google::protobuf::RepeatedPtrField<::stream::ScannerCrtlCfgData>& _internal_scannercfg() const;
+  ::google::protobuf::RepeatedPtrField<::stream::ScannerCrtlCfgData>* _internal_mutable_scannercfg();
+  public:
+  const ::stream::ScannerCrtlCfgData& scannercfg(int index) const;
+  ::stream::ScannerCrtlCfgData* add_scannercfg();
+  const ::google::protobuf::RepeatedPtrField< ::stream::ScannerCrtlCfgData >&
+      scannercfg() const;
+  // @@protoc_insertion_point(class_scope:stream.ScannerCrtlCfgResp)
+ private:
+  class _Internal;
+
+  friend class ::google::protobuf::internal::TcParser;
+  static const ::google::protobuf::internal::TcParseTable<0, 1, 1, 0, 2> _table_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::google::protobuf::RepeatedPtrField< ::stream::ScannerCrtlCfgData > scannercfg_;
+    mutable ::google::protobuf::internal::CachedSize _cached_size_;
+    PROTOBUF_TSAN_DECLARE_MEMBER
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_stream_2eproto;
+};// -------------------------------------------------------------------
+
+class ScannerCrtlCfgData final :
+    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:stream.ScannerCrtlCfgData) */ {
+ public:
+  inline ScannerCrtlCfgData() : ScannerCrtlCfgData(nullptr) {}
+  ~ScannerCrtlCfgData() override;
+  template<typename = void>
+  explicit PROTOBUF_CONSTEXPR ScannerCrtlCfgData(::google::protobuf::internal::ConstantInitialized);
+
+  ScannerCrtlCfgData(const ScannerCrtlCfgData& from);
+  ScannerCrtlCfgData(ScannerCrtlCfgData&& from) noexcept
+    : ScannerCrtlCfgData() {
+    *this = ::std::move(from);
+  }
+
+  inline ScannerCrtlCfgData& operator=(const ScannerCrtlCfgData& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ScannerCrtlCfgData& operator=(ScannerCrtlCfgData&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
+  }
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::google::protobuf::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::google::protobuf::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ScannerCrtlCfgData& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ScannerCrtlCfgData* internal_default_instance() {
+    return reinterpret_cast<const ScannerCrtlCfgData*>(
+               &_ScannerCrtlCfgData_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    13;
+
+  friend void swap(ScannerCrtlCfgData& a, ScannerCrtlCfgData& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ScannerCrtlCfgData* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::google::protobuf::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ScannerCrtlCfgData* other) {
+    if (other == this) return;
+    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ScannerCrtlCfgData* New(::google::protobuf::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ScannerCrtlCfgData>(arena);
+  }
+  using ::google::protobuf::Message::CopyFrom;
+  void CopyFrom(const ScannerCrtlCfgData& from);
+  using ::google::protobuf::Message::MergeFrom;
+  void MergeFrom( const ScannerCrtlCfgData& from) {
+    ScannerCrtlCfgData::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  ::size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
+  ::uint8_t* _InternalSerialize(
+      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::google::protobuf::Arena* arena);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ScannerCrtlCfgData* other);
+
+  private:
+  friend class ::google::protobuf::internal::AnyMetadata;
+  static ::absl::string_view FullMessageName() {
+    return "stream.ScannerCrtlCfgData";
+  }
+  protected:
+  explicit ScannerCrtlCfgData(::google::protobuf::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::google::protobuf::Message::ClassData*GetClassData() const final;
+
+  ::google::protobuf::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kFixPointDataFieldNumber = 2,
+    kPowerCompensateFieldNumber = 10,
+    kTPowerCompensateFieldNumber = 11,
+    kCardNameFieldNumber = 15,
+    kCardIPFieldNumber = 16,
+    kScanParamCfgFieldNumber = 3,
+    kHatchingParamsFieldNumber = 4,
+    kBorderParamsFieldNumber = 5,
+    kSupportParamsFieldNumber = 6,
+    kCorrectParamCfgFieldNumber = 7,
+    kScanTestCfgFieldNumber = 8,
+    kSkyWritingCfgFieldNumber = 9,
+    kSeqNoFieldNumber = 1,
+    kControlNoFieldNumber = 12,
+    kSerialNoFieldNumber = 13,
+    kControlTypeFieldNumber = 14,
+    kIsEnableFieldNumber = 17,
+    kHadAssignFieldNumber = 18,
+    kHadMatchFieldNumber = 19,
+  };
+  // repeated .stream.FixPointData fixPointData = 2;
+  int fixpointdata_size() const;
+  private:
+  int _internal_fixpointdata_size() const;
+
+  public:
+  void clear_fixpointdata() ;
+  ::stream::FixPointData* mutable_fixpointdata(int index);
+  ::google::protobuf::RepeatedPtrField< ::stream::FixPointData >*
+      mutable_fixpointdata();
+  private:
+  const ::google::protobuf::RepeatedPtrField<::stream::FixPointData>& _internal_fixpointdata() const;
+  ::google::protobuf::RepeatedPtrField<::stream::FixPointData>* _internal_mutable_fixpointdata();
+  public:
+  const ::stream::FixPointData& fixpointdata(int index) const;
+  ::stream::FixPointData* add_fixpointdata();
+  const ::google::protobuf::RepeatedPtrField< ::stream::FixPointData >&
+      fixpointdata() const;
+  // repeated .stream.PowerCompensate powerCompensate = 10;
+  int powercompensate_size() const;
+  private:
+  int _internal_powercompensate_size() const;
+
+  public:
+  void clear_powercompensate() ;
+  ::stream::PowerCompensate* mutable_powercompensate(int index);
+  ::google::protobuf::RepeatedPtrField< ::stream::PowerCompensate >*
+      mutable_powercompensate();
+  private:
+  const ::google::protobuf::RepeatedPtrField<::stream::PowerCompensate>& _internal_powercompensate() const;
+  ::google::protobuf::RepeatedPtrField<::stream::PowerCompensate>* _internal_mutable_powercompensate();
+  public:
+  const ::stream::PowerCompensate& powercompensate(int index) const;
+  ::stream::PowerCompensate* add_powercompensate();
+  const ::google::protobuf::RepeatedPtrField< ::stream::PowerCompensate >&
+      powercompensate() const;
+  // repeated .stream.TimePowerCompensate tPowerCompensate = 11;
+  int tpowercompensate_size() const;
+  private:
+  int _internal_tpowercompensate_size() const;
+
+  public:
+  void clear_tpowercompensate() ;
+  ::stream::TimePowerCompensate* mutable_tpowercompensate(int index);
+  ::google::protobuf::RepeatedPtrField< ::stream::TimePowerCompensate >*
+      mutable_tpowercompensate();
+  private:
+  const ::google::protobuf::RepeatedPtrField<::stream::TimePowerCompensate>& _internal_tpowercompensate() const;
+  ::google::protobuf::RepeatedPtrField<::stream::TimePowerCompensate>* _internal_mutable_tpowercompensate();
+  public:
+  const ::stream::TimePowerCompensate& tpowercompensate(int index) const;
+  ::stream::TimePowerCompensate* add_tpowercompensate();
+  const ::google::protobuf::RepeatedPtrField< ::stream::TimePowerCompensate >&
+      tpowercompensate() const;
+  // bytes cardName = 15;
+  void clear_cardname() ;
+  const std::string& cardname() const;
+  template <typename Arg_ = const std::string&, typename... Args_>
+  void set_cardname(Arg_&& arg, Args_... args);
+  std::string* mutable_cardname();
+  PROTOBUF_NODISCARD std::string* release_cardname();
+  void set_allocated_cardname(std::string* ptr);
+
+  private:
+  const std::string& _internal_cardname() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_cardname(
+      const std::string& value);
+  std::string* _internal_mutable_cardname();
+
+  public:
+  // bytes cardIP = 16;
+  void clear_cardip() ;
+  const std::string& cardip() const;
+  template <typename Arg_ = const std::string&, typename... Args_>
+  void set_cardip(Arg_&& arg, Args_... args);
+  std::string* mutable_cardip();
+  PROTOBUF_NODISCARD std::string* release_cardip();
+  void set_allocated_cardip(std::string* ptr);
+
+  private:
+  const std::string& _internal_cardip() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_cardip(
+      const std::string& value);
+  std::string* _internal_mutable_cardip();
+
+  public:
+  // .stream.ScanParamCfg scanParamCfg = 3;
+  bool has_scanparamcfg() const;
+  void clear_scanparamcfg() ;
+  const ::stream::ScanParamCfg& scanparamcfg() const;
+  PROTOBUF_NODISCARD ::stream::ScanParamCfg* release_scanparamcfg();
+  ::stream::ScanParamCfg* mutable_scanparamcfg();
+  void set_allocated_scanparamcfg(::stream::ScanParamCfg* value);
+  void unsafe_arena_set_allocated_scanparamcfg(::stream::ScanParamCfg* value);
+  ::stream::ScanParamCfg* unsafe_arena_release_scanparamcfg();
+
+  private:
+  const ::stream::ScanParamCfg& _internal_scanparamcfg() const;
+  ::stream::ScanParamCfg* _internal_mutable_scanparamcfg();
+
+  public:
+  // .stream.ScanParamCfg hatchingParams = 4;
+  bool has_hatchingparams() const;
+  void clear_hatchingparams() ;
+  const ::stream::ScanParamCfg& hatchingparams() const;
+  PROTOBUF_NODISCARD ::stream::ScanParamCfg* release_hatchingparams();
+  ::stream::ScanParamCfg* mutable_hatchingparams();
+  void set_allocated_hatchingparams(::stream::ScanParamCfg* value);
+  void unsafe_arena_set_allocated_hatchingparams(::stream::ScanParamCfg* value);
+  ::stream::ScanParamCfg* unsafe_arena_release_hatchingparams();
+
+  private:
+  const ::stream::ScanParamCfg& _internal_hatchingparams() const;
+  ::stream::ScanParamCfg* _internal_mutable_hatchingparams();
+
+  public:
+  // .stream.ScanParamCfg borderParams = 5;
+  bool has_borderparams() const;
+  void clear_borderparams() ;
+  const ::stream::ScanParamCfg& borderparams() const;
+  PROTOBUF_NODISCARD ::stream::ScanParamCfg* release_borderparams();
+  ::stream::ScanParamCfg* mutable_borderparams();
+  void set_allocated_borderparams(::stream::ScanParamCfg* value);
+  void unsafe_arena_set_allocated_borderparams(::stream::ScanParamCfg* value);
+  ::stream::ScanParamCfg* unsafe_arena_release_borderparams();
+
+  private:
+  const ::stream::ScanParamCfg& _internal_borderparams() const;
+  ::stream::ScanParamCfg* _internal_mutable_borderparams();
+
+  public:
+  // .stream.ScanParamCfg supportParams = 6;
+  bool has_supportparams() const;
+  void clear_supportparams() ;
+  const ::stream::ScanParamCfg& supportparams() const;
+  PROTOBUF_NODISCARD ::stream::ScanParamCfg* release_supportparams();
+  ::stream::ScanParamCfg* mutable_supportparams();
+  void set_allocated_supportparams(::stream::ScanParamCfg* value);
+  void unsafe_arena_set_allocated_supportparams(::stream::ScanParamCfg* value);
+  ::stream::ScanParamCfg* unsafe_arena_release_supportparams();
+
+  private:
+  const ::stream::ScanParamCfg& _internal_supportparams() const;
+  ::stream::ScanParamCfg* _internal_mutable_supportparams();
+
+  public:
+  // .stream.CorrectParamCfg correctParamCfg = 7;
+  bool has_correctparamcfg() const;
+  void clear_correctparamcfg() ;
+  const ::stream::CorrectParamCfg& correctparamcfg() const;
+  PROTOBUF_NODISCARD ::stream::CorrectParamCfg* release_correctparamcfg();
+  ::stream::CorrectParamCfg* mutable_correctparamcfg();
+  void set_allocated_correctparamcfg(::stream::CorrectParamCfg* value);
+  void unsafe_arena_set_allocated_correctparamcfg(::stream::CorrectParamCfg* value);
+  ::stream::CorrectParamCfg* unsafe_arena_release_correctparamcfg();
+
+  private:
+  const ::stream::CorrectParamCfg& _internal_correctparamcfg() const;
+  ::stream::CorrectParamCfg* _internal_mutable_correctparamcfg();
+
+  public:
+  // .stream.ScanTestCfg scanTestCfg = 8;
+  bool has_scantestcfg() const;
+  void clear_scantestcfg() ;
+  const ::stream::ScanTestCfg& scantestcfg() const;
+  PROTOBUF_NODISCARD ::stream::ScanTestCfg* release_scantestcfg();
+  ::stream::ScanTestCfg* mutable_scantestcfg();
+  void set_allocated_scantestcfg(::stream::ScanTestCfg* value);
+  void unsafe_arena_set_allocated_scantestcfg(::stream::ScanTestCfg* value);
+  ::stream::ScanTestCfg* unsafe_arena_release_scantestcfg();
+
+  private:
+  const ::stream::ScanTestCfg& _internal_scantestcfg() const;
+  ::stream::ScanTestCfg* _internal_mutable_scantestcfg();
+
+  public:
+  // .stream.SkyWritingCfg skyWritingCfg = 9;
+  bool has_skywritingcfg() const;
+  void clear_skywritingcfg() ;
+  const ::stream::SkyWritingCfg& skywritingcfg() const;
+  PROTOBUF_NODISCARD ::stream::SkyWritingCfg* release_skywritingcfg();
+  ::stream::SkyWritingCfg* mutable_skywritingcfg();
+  void set_allocated_skywritingcfg(::stream::SkyWritingCfg* value);
+  void unsafe_arena_set_allocated_skywritingcfg(::stream::SkyWritingCfg* value);
+  ::stream::SkyWritingCfg* unsafe_arena_release_skywritingcfg();
+
+  private:
+  const ::stream::SkyWritingCfg& _internal_skywritingcfg() const;
+  ::stream::SkyWritingCfg* _internal_mutable_skywritingcfg();
+
+  public:
+  // int32 seqNo = 1;
+  void clear_seqno() ;
+  ::int32_t seqno() const;
+  void set_seqno(::int32_t value);
+
+  private:
+  ::int32_t _internal_seqno() const;
+  void _internal_set_seqno(::int32_t value);
+
+  public:
+  // int32 controlNo = 12;
+  void clear_controlno() ;
+  ::int32_t controlno() const;
+  void set_controlno(::int32_t value);
+
+  private:
+  ::int32_t _internal_controlno() const;
+  void _internal_set_controlno(::int32_t value);
+
+  public:
+  // int32 serialNo = 13;
+  void clear_serialno() ;
+  ::int32_t serialno() const;
+  void set_serialno(::int32_t value);
+
+  private:
+  ::int32_t _internal_serialno() const;
+  void _internal_set_serialno(::int32_t value);
+
+  public:
+  // int32 controlType = 14;
+  void clear_controltype() ;
+  ::int32_t controltype() const;
+  void set_controltype(::int32_t value);
+
+  private:
+  ::int32_t _internal_controltype() const;
+  void _internal_set_controltype(::int32_t value);
+
+  public:
+  // bool isEnable = 17;
+  void clear_isenable() ;
+  bool isenable() const;
+  void set_isenable(bool value);
+
+  private:
+  bool _internal_isenable() const;
+  void _internal_set_isenable(bool value);
+
+  public:
+  // bool hadAssign = 18;
+  void clear_hadassign() ;
+  bool hadassign() const;
+  void set_hadassign(bool value);
+
+  private:
+  bool _internal_hadassign() const;
+  void _internal_set_hadassign(bool value);
+
+  public:
+  // bool hadMatch = 19;
+  void clear_hadmatch() ;
+  bool hadmatch() const;
+  void set_hadmatch(bool value);
+
+  private:
+  bool _internal_hadmatch() const;
+  void _internal_set_hadmatch(bool value);
+
+  public:
+  // @@protoc_insertion_point(class_scope:stream.ScannerCrtlCfgData)
+ private:
+  class _Internal;
+
+  friend class ::google::protobuf::internal::TcParser;
+  static const ::google::protobuf::internal::TcParseTable<5, 19, 10, 0, 2> _table_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::google::protobuf::internal::HasBits<1> _has_bits_;
+    mutable ::google::protobuf::internal::CachedSize _cached_size_;
+    ::google::protobuf::RepeatedPtrField< ::stream::FixPointData > fixpointdata_;
+    ::google::protobuf::RepeatedPtrField< ::stream::PowerCompensate > powercompensate_;
+    ::google::protobuf::RepeatedPtrField< ::stream::TimePowerCompensate > tpowercompensate_;
+    ::google::protobuf::internal::ArenaStringPtr cardname_;
+    ::google::protobuf::internal::ArenaStringPtr cardip_;
+    ::stream::ScanParamCfg* scanparamcfg_;
+    ::stream::ScanParamCfg* hatchingparams_;
+    ::stream::ScanParamCfg* borderparams_;
+    ::stream::ScanParamCfg* supportparams_;
+    ::stream::CorrectParamCfg* correctparamcfg_;
+    ::stream::ScanTestCfg* scantestcfg_;
+    ::stream::SkyWritingCfg* skywritingcfg_;
+    ::int32_t seqno_;
+    ::int32_t controlno_;
+    ::int32_t serialno_;
+    ::int32_t controltype_;
+    bool isenable_;
+    bool hadassign_;
+    bool hadmatch_;
+    PROTOBUF_TSAN_DECLARE_MEMBER
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_stream_2eproto;
+};// -------------------------------------------------------------------
+
+class FixPointData final :
+    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:stream.FixPointData) */ {
+ public:
+  inline FixPointData() : FixPointData(nullptr) {}
+  ~FixPointData() override;
+  template<typename = void>
+  explicit PROTOBUF_CONSTEXPR FixPointData(::google::protobuf::internal::ConstantInitialized);
+
+  FixPointData(const FixPointData& from);
+  FixPointData(FixPointData&& from) noexcept
+    : FixPointData() {
+    *this = ::std::move(from);
+  }
+
+  inline FixPointData& operator=(const FixPointData& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline FixPointData& operator=(FixPointData&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
+  }
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::google::protobuf::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::google::protobuf::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const FixPointData& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const FixPointData* internal_default_instance() {
+    return reinterpret_cast<const FixPointData*>(
+               &_FixPointData_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    14;
+
+  friend void swap(FixPointData& a, FixPointData& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(FixPointData* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::google::protobuf::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(FixPointData* other) {
+    if (other == this) return;
+    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  FixPointData* New(::google::protobuf::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<FixPointData>(arena);
+  }
+  using ::google::protobuf::Message::CopyFrom;
+  void CopyFrom(const FixPointData& from);
+  using ::google::protobuf::Message::MergeFrom;
+  void MergeFrom( const FixPointData& from) {
+    FixPointData::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  ::size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
+  ::uint8_t* _InternalSerialize(
+      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::google::protobuf::Arena* arena);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(FixPointData* other);
+
+  private:
+  friend class ::google::protobuf::internal::AnyMetadata;
+  static ::absl::string_view FullMessageName() {
+    return "stream.FixPointData";
+  }
+  protected:
+  explicit FixPointData(::google::protobuf::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::google::protobuf::Message::ClassData*GetClassData() const final;
+
+  ::google::protobuf::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kIdFieldNumber = 1,
+    kCnoFieldNumber = 2,
+    kPointXFieldNumber = 3,
+    kPointYFieldNumber = 4,
+    kDurationFieldNumber = 5,
+  };
+  // int32 id = 1;
+  void clear_id() ;
+  ::int32_t id() const;
+  void set_id(::int32_t value);
+
+  private:
+  ::int32_t _internal_id() const;
+  void _internal_set_id(::int32_t value);
+
+  public:
+  // int32 cno = 2;
+  void clear_cno() ;
+  ::int32_t cno() const;
+  void set_cno(::int32_t value);
+
+  private:
+  ::int32_t _internal_cno() const;
+  void _internal_set_cno(::int32_t value);
+
+  public:
+  // float pointX = 3;
+  void clear_pointx() ;
+  float pointx() const;
+  void set_pointx(float value);
+
+  private:
+  float _internal_pointx() const;
+  void _internal_set_pointx(float value);
+
+  public:
+  // float pointY = 4;
+  void clear_pointy() ;
+  float pointy() const;
+  void set_pointy(float value);
+
+  private:
+  float _internal_pointy() const;
+  void _internal_set_pointy(float value);
+
+  public:
+  // uint32 duration = 5;
+  void clear_duration() ;
+  ::uint32_t duration() const;
+  void set_duration(::uint32_t value);
+
+  private:
+  ::uint32_t _internal_duration() const;
+  void _internal_set_duration(::uint32_t value);
+
+  public:
+  // @@protoc_insertion_point(class_scope:stream.FixPointData)
+ private:
+  class _Internal;
+
+  friend class ::google::protobuf::internal::TcParser;
+  static const ::google::protobuf::internal::TcParseTable<3, 5, 0, 0, 2> _table_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::int32_t id_;
+    ::int32_t cno_;
+    float pointx_;
+    float pointy_;
+    ::uint32_t duration_;
+    mutable ::google::protobuf::internal::CachedSize _cached_size_;
+    PROTOBUF_TSAN_DECLARE_MEMBER
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_stream_2eproto;
+};// -------------------------------------------------------------------
+
+class ScanParamCfg final :
+    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:stream.ScanParamCfg) */ {
+ public:
+  inline ScanParamCfg() : ScanParamCfg(nullptr) {}
+  ~ScanParamCfg() override;
+  template<typename = void>
+  explicit PROTOBUF_CONSTEXPR ScanParamCfg(::google::protobuf::internal::ConstantInitialized);
+
+  ScanParamCfg(const ScanParamCfg& from);
+  ScanParamCfg(ScanParamCfg&& from) noexcept
+    : ScanParamCfg() {
+    *this = ::std::move(from);
+  }
+
+  inline ScanParamCfg& operator=(const ScanParamCfg& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ScanParamCfg& operator=(ScanParamCfg&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
+  }
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::google::protobuf::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::google::protobuf::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ScanParamCfg& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ScanParamCfg* internal_default_instance() {
+    return reinterpret_cast<const ScanParamCfg*>(
+               &_ScanParamCfg_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    15;
+
+  friend void swap(ScanParamCfg& a, ScanParamCfg& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ScanParamCfg* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::google::protobuf::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ScanParamCfg* other) {
+    if (other == this) return;
+    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ScanParamCfg* New(::google::protobuf::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ScanParamCfg>(arena);
+  }
+  using ::google::protobuf::Message::CopyFrom;
+  void CopyFrom(const ScanParamCfg& from);
+  using ::google::protobuf::Message::MergeFrom;
+  void MergeFrom( const ScanParamCfg& from) {
+    ScanParamCfg::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  ::size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
+  ::uint8_t* _InternalSerialize(
+      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::google::protobuf::Arena* arena);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ScanParamCfg* other);
+
+  private:
+  friend class ::google::protobuf::internal::AnyMetadata;
+  static ::absl::string_view FullMessageName() {
+    return "stream.ScanParamCfg";
+  }
+  protected:
+  explicit ScanParamCfg(::google::protobuf::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::google::protobuf::Message::ClassData*GetClassData() const final;
+
+  ::google::protobuf::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kEdgeLevelFieldNumber = 1,
+    kEdgeLevelMinFieldNumber = 2,
+    kEdgeLevelMaxFieldNumber = 3,
+    kJumpDelayFieldNumber = 4,
+    kJumpDelayMinFieldNumber = 5,
+    kJumpDelayMaxFieldNumber = 6,
+    kScanDelayFieldNumber = 7,
+    kScanDelayMinFieldNumber = 8,
+    kScanDelayMaxFieldNumber = 9,
+    kPolygonDelayFieldNumber = 10,
+    kPolygonDelayMinFieldNumber = 11,
+    kPolygonDelayMaxFieldNumber = 12,
+    kLaseroffDelayFieldNumber = 13,
+    kLaseroffDelayMinFieldNumber = 14,
+    kLaseroffDelayMaxFieldNumber = 15,
+    kLaseronDelayFieldNumber = 16,
+    kLaseronDelayMinFieldNumber = 17,
+    kLaseronDelayMaxFieldNumber = 18,
+    kMinJumpDelayFieldNumber = 19,
+    kMinJumpDelayMinFieldNumber = 20,
+    kMinJumpDelayMaxFieldNumber = 21,
+    kJumpLengthLimitFieldNumber = 22,
+    kJumpLengthLimitMinFieldNumber = 23,
+    kJumpLengthLimitMaxFieldNumber = 24,
+    kJumpSpeedFieldNumber = 25,
+    kJumpSpeedMinFieldNumber = 26,
+    kJumpSpeedMaxFieldNumber = 27,
+    kMarkSpeedFieldNumber = 28,
+    kMarkSpeedMinFieldNumber = 29,
+    kMarkSpeedMaxFieldNumber = 30,
+  };
+  // int32 edgeLevel = 1;
+  void clear_edgelevel() ;
+  ::int32_t edgelevel() const;
+  void set_edgelevel(::int32_t value);
+
+  private:
+  ::int32_t _internal_edgelevel() const;
+  void _internal_set_edgelevel(::int32_t value);
+
+  public:
+  // int32 edgeLevelMin = 2;
+  void clear_edgelevelmin() ;
+  ::int32_t edgelevelmin() const;
+  void set_edgelevelmin(::int32_t value);
+
+  private:
+  ::int32_t _internal_edgelevelmin() const;
+  void _internal_set_edgelevelmin(::int32_t value);
+
+  public:
+  // int32 edgeLevelMax = 3;
+  void clear_edgelevelmax() ;
+  ::int32_t edgelevelmax() const;
+  void set_edgelevelmax(::int32_t value);
+
+  private:
+  ::int32_t _internal_edgelevelmax() const;
+  void _internal_set_edgelevelmax(::int32_t value);
+
+  public:
+  // uint32 jumpDelay = 4;
+  void clear_jumpdelay() ;
+  ::uint32_t jumpdelay() const;
+  void set_jumpdelay(::uint32_t value);
+
+  private:
+  ::uint32_t _internal_jumpdelay() const;
+  void _internal_set_jumpdelay(::uint32_t value);
+
+  public:
+  // uint32 jumpDelayMin = 5;
+  void clear_jumpdelaymin() ;
+  ::uint32_t jumpdelaymin() const;
+  void set_jumpdelaymin(::uint32_t value);
+
+  private:
+  ::uint32_t _internal_jumpdelaymin() const;
+  void _internal_set_jumpdelaymin(::uint32_t value);
+
+  public:
+  // uint32 jumpDelayMax = 6;
+  void clear_jumpdelaymax() ;
+  ::uint32_t jumpdelaymax() const;
+  void set_jumpdelaymax(::uint32_t value);
+
+  private:
+  ::uint32_t _internal_jumpdelaymax() const;
+  void _internal_set_jumpdelaymax(::uint32_t value);
+
+  public:
+  // uint32 scanDelay = 7;
+  void clear_scandelay() ;
+  ::uint32_t scandelay() const;
+  void set_scandelay(::uint32_t value);
+
+  private:
+  ::uint32_t _internal_scandelay() const;
+  void _internal_set_scandelay(::uint32_t value);
+
+  public:
+  // uint32 scanDelayMin = 8;
+  void clear_scandelaymin() ;
+  ::uint32_t scandelaymin() const;
+  void set_scandelaymin(::uint32_t value);
+
+  private:
+  ::uint32_t _internal_scandelaymin() const;
+  void _internal_set_scandelaymin(::uint32_t value);
+
+  public:
+  // uint32 scanDelayMax = 9;
+  void clear_scandelaymax() ;
+  ::uint32_t scandelaymax() const;
+  void set_scandelaymax(::uint32_t value);
+
+  private:
+  ::uint32_t _internal_scandelaymax() const;
+  void _internal_set_scandelaymax(::uint32_t value);
+
+  public:
+  // uint32 polygonDelay = 10;
+  void clear_polygondelay() ;
+  ::uint32_t polygondelay() const;
+  void set_polygondelay(::uint32_t value);
+
+  private:
+  ::uint32_t _internal_polygondelay() const;
+  void _internal_set_polygondelay(::uint32_t value);
+
+  public:
+  // uint32 polygonDelayMin = 11;
+  void clear_polygondelaymin() ;
+  ::uint32_t polygondelaymin() const;
+  void set_polygondelaymin(::uint32_t value);
+
+  private:
+  ::uint32_t _internal_polygondelaymin() const;
+  void _internal_set_polygondelaymin(::uint32_t value);
+
+  public:
+  // uint32 polygonDelayMax = 12;
+  void clear_polygondelaymax() ;
+  ::uint32_t polygondelaymax() const;
+  void set_polygondelaymax(::uint32_t value);
+
+  private:
+  ::uint32_t _internal_polygondelaymax() const;
+  void _internal_set_polygondelaymax(::uint32_t value);
+
+  public:
+  // int64 laseroffDelay = 13;
+  void clear_laseroffdelay() ;
+  ::int64_t laseroffdelay() const;
+  void set_laseroffdelay(::int64_t value);
+
+  private:
+  ::int64_t _internal_laseroffdelay() const;
+  void _internal_set_laseroffdelay(::int64_t value);
+
+  public:
+  // int64 laseroffDelayMin = 14;
+  void clear_laseroffdelaymin() ;
+  ::int64_t laseroffdelaymin() const;
+  void set_laseroffdelaymin(::int64_t value);
+
+  private:
+  ::int64_t _internal_laseroffdelaymin() const;
+  void _internal_set_laseroffdelaymin(::int64_t value);
+
+  public:
+  // int64 laseroffDelayMax = 15;
+  void clear_laseroffdelaymax() ;
+  ::int64_t laseroffdelaymax() const;
+  void set_laseroffdelaymax(::int64_t value);
+
+  private:
+  ::int64_t _internal_laseroffdelaymax() const;
+  void _internal_set_laseroffdelaymax(::int64_t value);
+
+  public:
+  // int64 laseronDelay = 16;
+  void clear_laserondelay() ;
+  ::int64_t laserondelay() const;
+  void set_laserondelay(::int64_t value);
+
+  private:
+  ::int64_t _internal_laserondelay() const;
+  void _internal_set_laserondelay(::int64_t value);
+
+  public:
+  // int64 laseronDelayMin = 17;
+  void clear_laserondelaymin() ;
+  ::int64_t laserondelaymin() const;
+  void set_laserondelaymin(::int64_t value);
+
+  private:
+  ::int64_t _internal_laserondelaymin() const;
+  void _internal_set_laserondelaymin(::int64_t value);
+
+  public:
+  // int64 laseronDelayMax = 18;
+  void clear_laserondelaymax() ;
+  ::int64_t laserondelaymax() const;
+  void set_laserondelaymax(::int64_t value);
+
+  private:
+  ::int64_t _internal_laserondelaymax() const;
+  void _internal_set_laserondelaymax(::int64_t value);
+
+  public:
+  // uint32 minJumpDelay = 19;
+  void clear_minjumpdelay() ;
+  ::uint32_t minjumpdelay() const;
+  void set_minjumpdelay(::uint32_t value);
+
+  private:
+  ::uint32_t _internal_minjumpdelay() const;
+  void _internal_set_minjumpdelay(::uint32_t value);
+
+  public:
+  // uint32 minJumpDelayMin = 20;
+  void clear_minjumpdelaymin() ;
+  ::uint32_t minjumpdelaymin() const;
+  void set_minjumpdelaymin(::uint32_t value);
+
+  private:
+  ::uint32_t _internal_minjumpdelaymin() const;
+  void _internal_set_minjumpdelaymin(::uint32_t value);
+
+  public:
+  // uint32 minJumpDelayMax = 21;
+  void clear_minjumpdelaymax() ;
+  ::uint32_t minjumpdelaymax() const;
+  void set_minjumpdelaymax(::uint32_t value);
+
+  private:
+  ::uint32_t _internal_minjumpdelaymax() const;
+  void _internal_set_minjumpdelaymax(::uint32_t value);
+
+  public:
+  // uint32 jumpLengthLimit = 22;
+  void clear_jumplengthlimit() ;
+  ::uint32_t jumplengthlimit() const;
+  void set_jumplengthlimit(::uint32_t value);
+
+  private:
+  ::uint32_t _internal_jumplengthlimit() const;
+  void _internal_set_jumplengthlimit(::uint32_t value);
+
+  public:
+  // uint32 jumpLengthLimitMin = 23;
+  void clear_jumplengthlimitmin() ;
+  ::uint32_t jumplengthlimitmin() const;
+  void set_jumplengthlimitmin(::uint32_t value);
+
+  private:
+  ::uint32_t _internal_jumplengthlimitmin() const;
+  void _internal_set_jumplengthlimitmin(::uint32_t value);
+
+  public:
+  // uint32 jumpLengthLimitMax = 24;
+  void clear_jumplengthlimitmax() ;
+  ::uint32_t jumplengthlimitmax() const;
+  void set_jumplengthlimitmax(::uint32_t value);
+
+  private:
+  ::uint32_t _internal_jumplengthlimitmax() const;
+  void _internal_set_jumplengthlimitmax(::uint32_t value);
+
+  public:
+  // double jumpSpeed = 25;
+  void clear_jumpspeed() ;
+  double jumpspeed() const;
+  void set_jumpspeed(double value);
+
+  private:
+  double _internal_jumpspeed() const;
+  void _internal_set_jumpspeed(double value);
+
+  public:
+  // double jumpSpeedMin = 26;
+  void clear_jumpspeedmin() ;
+  double jumpspeedmin() const;
+  void set_jumpspeedmin(double value);
+
+  private:
+  double _internal_jumpspeedmin() const;
+  void _internal_set_jumpspeedmin(double value);
+
+  public:
+  // double jumpSpeedMax = 27;
+  void clear_jumpspeedmax() ;
+  double jumpspeedmax() const;
+  void set_jumpspeedmax(double value);
+
+  private:
+  double _internal_jumpspeedmax() const;
+  void _internal_set_jumpspeedmax(double value);
+
+  public:
+  // double markSpeed = 28;
+  void clear_markspeed() ;
+  double markspeed() const;
+  void set_markspeed(double value);
+
+  private:
+  double _internal_markspeed() const;
+  void _internal_set_markspeed(double value);
+
+  public:
+  // double markSpeedMin = 29;
+  void clear_markspeedmin() ;
+  double markspeedmin() const;
+  void set_markspeedmin(double value);
+
+  private:
+  double _internal_markspeedmin() const;
+  void _internal_set_markspeedmin(double value);
+
+  public:
+  // double markSpeedMax = 30;
+  void clear_markspeedmax() ;
+  double markspeedmax() const;
+  void set_markspeedmax(double value);
+
+  private:
+  double _internal_markspeedmax() const;
+  void _internal_set_markspeedmax(double value);
+
+  public:
+  // @@protoc_insertion_point(class_scope:stream.ScanParamCfg)
+ private:
+  class _Internal;
+
+  friend class ::google::protobuf::internal::TcParser;
+  static const ::google::protobuf::internal::TcParseTable<5, 30, 0, 0, 2> _table_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::int32_t edgelevel_;
+    ::int32_t edgelevelmin_;
+    ::int32_t edgelevelmax_;
+    ::uint32_t jumpdelay_;
+    ::uint32_t jumpdelaymin_;
+    ::uint32_t jumpdelaymax_;
+    ::uint32_t scandelay_;
+    ::uint32_t scandelaymin_;
+    ::uint32_t scandelaymax_;
+    ::uint32_t polygondelay_;
+    ::uint32_t polygondelaymin_;
+    ::uint32_t polygondelaymax_;
+    ::int64_t laseroffdelay_;
+    ::int64_t laseroffdelaymin_;
+    ::int64_t laseroffdelaymax_;
+    ::int64_t laserondelay_;
+    ::int64_t laserondelaymin_;
+    ::int64_t laserondelaymax_;
+    ::uint32_t minjumpdelay_;
+    ::uint32_t minjumpdelaymin_;
+    ::uint32_t minjumpdelaymax_;
+    ::uint32_t jumplengthlimit_;
+    ::uint32_t jumplengthlimitmin_;
+    ::uint32_t jumplengthlimitmax_;
+    double jumpspeed_;
+    double jumpspeedmin_;
+    double jumpspeedmax_;
+    double markspeed_;
+    double markspeedmin_;
+    double markspeedmax_;
+    mutable ::google::protobuf::internal::CachedSize _cached_size_;
+    PROTOBUF_TSAN_DECLARE_MEMBER
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_stream_2eproto;
+};// -------------------------------------------------------------------
+
+class CorrectParamCfg final :
+    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:stream.CorrectParamCfg) */ {
+ public:
+  inline CorrectParamCfg() : CorrectParamCfg(nullptr) {}
+  ~CorrectParamCfg() override;
+  template<typename = void>
+  explicit PROTOBUF_CONSTEXPR CorrectParamCfg(::google::protobuf::internal::ConstantInitialized);
+
+  CorrectParamCfg(const CorrectParamCfg& from);
+  CorrectParamCfg(CorrectParamCfg&& from) noexcept
+    : CorrectParamCfg() {
+    *this = ::std::move(from);
+  }
+
+  inline CorrectParamCfg& operator=(const CorrectParamCfg& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline CorrectParamCfg& operator=(CorrectParamCfg&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
+  }
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::google::protobuf::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::google::protobuf::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const CorrectParamCfg& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const CorrectParamCfg* internal_default_instance() {
+    return reinterpret_cast<const CorrectParamCfg*>(
+               &_CorrectParamCfg_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    16;
+
+  friend void swap(CorrectParamCfg& a, CorrectParamCfg& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(CorrectParamCfg* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::google::protobuf::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(CorrectParamCfg* other) {
+    if (other == this) return;
+    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  CorrectParamCfg* New(::google::protobuf::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<CorrectParamCfg>(arena);
+  }
+  using ::google::protobuf::Message::CopyFrom;
+  void CopyFrom(const CorrectParamCfg& from);
+  using ::google::protobuf::Message::MergeFrom;
+  void MergeFrom( const CorrectParamCfg& from) {
+    CorrectParamCfg::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  ::size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
+  ::uint8_t* _InternalSerialize(
+      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::google::protobuf::Arena* arena);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(CorrectParamCfg* other);
+
+  private:
+  friend class ::google::protobuf::internal::AnyMetadata;
+  static ::absl::string_view FullMessageName() {
+    return "stream.CorrectParamCfg";
+  }
+  protected:
+  explicit CorrectParamCfg(::google::protobuf::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::google::protobuf::Message::ClassData*GetClassData() const final;
+
+  ::google::protobuf::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kXmeasureMinFieldNumber = 1,
+    kXmeasureMaxFieldNumber = 2,
+    kYmeasureMinFieldNumber = 3,
+    kYmeasureMaxFieldNumber = 4,
+    kXposfixFieldNumber = 5,
+    kYposfixFieldNumber = 6,
+    kScanAngleFieldNumber = 7,
+    kScanAngleMinFieldNumber = 8,
+    kScanAngleMaxFieldNumber = 9,
+    kFixAngleFieldNumber = 10,
+    kFixAngleMinFieldNumber = 11,
+    kFixAngleMaxFieldNumber = 12,
+    kXcorrectFieldNumber = 13,
+    kYcorrectFieldNumber = 14,
+    kXcorrectMinFieldNumber = 15,
+    kXcorrectMaxFieldNumber = 16,
+    kYcorrectMinFieldNumber = 17,
+    kYcorrectMaxFieldNumber = 18,
+    kRealXOffsetFieldNumber = 19,
+    kRealYOffsetFieldNumber = 20,
+    kFactorKFieldNumber = 21,
+    kDefocusRatioFieldNumber = 24,
+    kDefocusRatioMinFieldNumber = 25,
+    kDefocusRatioMaxFieldNumber = 26,
+    kIsCorrectFile3DFieldNumber = 22,
+    kIsDynamicFocusFieldNumber = 23,
+  };
+  // double xmeasureMin = 1;
+  void clear_xmeasuremin() ;
+  double xmeasuremin() const;
+  void set_xmeasuremin(double value);
+
+  private:
+  double _internal_xmeasuremin() const;
+  void _internal_set_xmeasuremin(double value);
+
+  public:
+  // double xmeasureMax = 2;
+  void clear_xmeasuremax() ;
+  double xmeasuremax() const;
+  void set_xmeasuremax(double value);
+
+  private:
+  double _internal_xmeasuremax() const;
+  void _internal_set_xmeasuremax(double value);
+
+  public:
+  // double ymeasureMin = 3;
+  void clear_ymeasuremin() ;
+  double ymeasuremin() const;
+  void set_ymeasuremin(double value);
+
+  private:
+  double _internal_ymeasuremin() const;
+  void _internal_set_ymeasuremin(double value);
+
+  public:
+  // double ymeasureMax = 4;
+  void clear_ymeasuremax() ;
+  double ymeasuremax() const;
+  void set_ymeasuremax(double value);
+
+  private:
+  double _internal_ymeasuremax() const;
+  void _internal_set_ymeasuremax(double value);
+
+  public:
+  // double xposfix = 5;
+  void clear_xposfix() ;
+  double xposfix() const;
+  void set_xposfix(double value);
+
+  private:
+  double _internal_xposfix() const;
+  void _internal_set_xposfix(double value);
+
+  public:
+  // double yposfix = 6;
+  void clear_yposfix() ;
+  double yposfix() const;
+  void set_yposfix(double value);
+
+  private:
+  double _internal_yposfix() const;
+  void _internal_set_yposfix(double value);
+
+  public:
+  // double scanAngle = 7;
+  void clear_scanangle() ;
+  double scanangle() const;
+  void set_scanangle(double value);
+
+  private:
+  double _internal_scanangle() const;
+  void _internal_set_scanangle(double value);
+
+  public:
+  // double scanAngleMin = 8;
+  void clear_scananglemin() ;
+  double scananglemin() const;
+  void set_scananglemin(double value);
+
+  private:
+  double _internal_scananglemin() const;
+  void _internal_set_scananglemin(double value);
+
+  public:
+  // double scanAngleMax = 9;
+  void clear_scananglemax() ;
+  double scananglemax() const;
+  void set_scananglemax(double value);
+
+  private:
+  double _internal_scananglemax() const;
+  void _internal_set_scananglemax(double value);
+
+  public:
+  // double fixAngle = 10;
+  void clear_fixangle() ;
+  double fixangle() const;
+  void set_fixangle(double value);
+
+  private:
+  double _internal_fixangle() const;
+  void _internal_set_fixangle(double value);
+
+  public:
+  // double fixAngleMin = 11;
+  void clear_fixanglemin() ;
+  double fixanglemin() const;
+  void set_fixanglemin(double value);
+
+  private:
+  double _internal_fixanglemin() const;
+  void _internal_set_fixanglemin(double value);
+
+  public:
+  // double fixAngleMax = 12;
+  void clear_fixanglemax() ;
+  double fixanglemax() const;
+  void set_fixanglemax(double value);
+
+  private:
+  double _internal_fixanglemax() const;
+  void _internal_set_fixanglemax(double value);
+
+  public:
+  // double xcorrect = 13;
+  void clear_xcorrect() ;
+  double xcorrect() const;
+  void set_xcorrect(double value);
+
+  private:
+  double _internal_xcorrect() const;
+  void _internal_set_xcorrect(double value);
+
+  public:
+  // double ycorrect = 14;
+  void clear_ycorrect() ;
+  double ycorrect() const;
+  void set_ycorrect(double value);
+
+  private:
+  double _internal_ycorrect() const;
+  void _internal_set_ycorrect(double value);
+
+  public:
+  // double xcorrectMin = 15;
+  void clear_xcorrectmin() ;
+  double xcorrectmin() const;
+  void set_xcorrectmin(double value);
+
+  private:
+  double _internal_xcorrectmin() const;
+  void _internal_set_xcorrectmin(double value);
+
+  public:
+  // double xcorrectMax = 16;
+  void clear_xcorrectmax() ;
+  double xcorrectmax() const;
+  void set_xcorrectmax(double value);
+
+  private:
+  double _internal_xcorrectmax() const;
+  void _internal_set_xcorrectmax(double value);
+
+  public:
+  // double ycorrectMin = 17;
+  void clear_ycorrectmin() ;
+  double ycorrectmin() const;
+  void set_ycorrectmin(double value);
+
+  private:
+  double _internal_ycorrectmin() const;
+  void _internal_set_ycorrectmin(double value);
+
+  public:
+  // double ycorrectMax = 18;
+  void clear_ycorrectmax() ;
+  double ycorrectmax() const;
+  void set_ycorrectmax(double value);
+
+  private:
+  double _internal_ycorrectmax() const;
+  void _internal_set_ycorrectmax(double value);
+
+  public:
+  // double realXOffset = 19;
+  void clear_realxoffset() ;
+  double realxoffset() const;
+  void set_realxoffset(double value);
+
+  private:
+  double _internal_realxoffset() const;
+  void _internal_set_realxoffset(double value);
+
+  public:
+  // double realYOffset = 20;
+  void clear_realyoffset() ;
+  double realyoffset() const;
+  void set_realyoffset(double value);
+
+  private:
+  double _internal_realyoffset() const;
+  void _internal_set_realyoffset(double value);
+
+  public:
+  // double factorK = 21;
+  void clear_factork() ;
+  double factork() const;
+  void set_factork(double value);
+
+  private:
+  double _internal_factork() const;
+  void _internal_set_factork(double value);
+
+  public:
+  // double defocusRatio = 24;
+  void clear_defocusratio() ;
+  double defocusratio() const;
+  void set_defocusratio(double value);
+
+  private:
+  double _internal_defocusratio() const;
+  void _internal_set_defocusratio(double value);
+
+  public:
+  // double defocusRatioMin = 25;
+  void clear_defocusratiomin() ;
+  double defocusratiomin() const;
+  void set_defocusratiomin(double value);
+
+  private:
+  double _internal_defocusratiomin() const;
+  void _internal_set_defocusratiomin(double value);
+
+  public:
+  // double defocusRatioMax = 26;
+  void clear_defocusratiomax() ;
+  double defocusratiomax() const;
+  void set_defocusratiomax(double value);
+
+  private:
+  double _internal_defocusratiomax() const;
+  void _internal_set_defocusratiomax(double value);
+
+  public:
+  // bool isCorrectFile3D = 22;
+  void clear_iscorrectfile3d() ;
+  bool iscorrectfile3d() const;
+  void set_iscorrectfile3d(bool value);
+
+  private:
+  bool _internal_iscorrectfile3d() const;
+  void _internal_set_iscorrectfile3d(bool value);
+
+  public:
+  // bool isDynamicFocus = 23;
+  void clear_isdynamicfocus() ;
+  bool isdynamicfocus() const;
+  void set_isdynamicfocus(bool value);
+
+  private:
+  bool _internal_isdynamicfocus() const;
+  void _internal_set_isdynamicfocus(bool value);
+
+  public:
+  // @@protoc_insertion_point(class_scope:stream.CorrectParamCfg)
+ private:
+  class _Internal;
+
+  friend class ::google::protobuf::internal::TcParser;
+  static const ::google::protobuf::internal::TcParseTable<5, 26, 0, 0, 2> _table_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    double xmeasuremin_;
+    double xmeasuremax_;
+    double ymeasuremin_;
+    double ymeasuremax_;
+    double xposfix_;
+    double yposfix_;
+    double scanangle_;
+    double scananglemin_;
+    double scananglemax_;
+    double fixangle_;
+    double fixanglemin_;
+    double fixanglemax_;
+    double xcorrect_;
+    double ycorrect_;
+    double xcorrectmin_;
+    double xcorrectmax_;
+    double ycorrectmin_;
+    double ycorrectmax_;
+    double realxoffset_;
+    double realyoffset_;
+    double factork_;
+    double defocusratio_;
+    double defocusratiomin_;
+    double defocusratiomax_;
+    bool iscorrectfile3d_;
+    bool isdynamicfocus_;
+    mutable ::google::protobuf::internal::CachedSize _cached_size_;
+    PROTOBUF_TSAN_DECLARE_MEMBER
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_stream_2eproto;
+};// -------------------------------------------------------------------
+
+class ScanTestCfg final :
+    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:stream.ScanTestCfg) */ {
+ public:
+  inline ScanTestCfg() : ScanTestCfg(nullptr) {}
+  ~ScanTestCfg() override;
+  template<typename = void>
+  explicit PROTOBUF_CONSTEXPR ScanTestCfg(::google::protobuf::internal::ConstantInitialized);
+
+  ScanTestCfg(const ScanTestCfg& from);
+  ScanTestCfg(ScanTestCfg&& from) noexcept
+    : ScanTestCfg() {
+    *this = ::std::move(from);
+  }
+
+  inline ScanTestCfg& operator=(const ScanTestCfg& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ScanTestCfg& operator=(ScanTestCfg&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
+  }
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::google::protobuf::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::google::protobuf::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ScanTestCfg& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ScanTestCfg* internal_default_instance() {
+    return reinterpret_cast<const ScanTestCfg*>(
+               &_ScanTestCfg_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    17;
+
+  friend void swap(ScanTestCfg& a, ScanTestCfg& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ScanTestCfg* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::google::protobuf::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ScanTestCfg* other) {
+    if (other == this) return;
+    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ScanTestCfg* New(::google::protobuf::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ScanTestCfg>(arena);
+  }
+  using ::google::protobuf::Message::CopyFrom;
+  void CopyFrom(const ScanTestCfg& from);
+  using ::google::protobuf::Message::MergeFrom;
+  void MergeFrom( const ScanTestCfg& from) {
+    ScanTestCfg::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  ::size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
+  ::uint8_t* _InternalSerialize(
+      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::google::protobuf::Arena* arena);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ScanTestCfg* other);
+
+  private:
+  friend class ::google::protobuf::internal::AnyMetadata;
+  static ::absl::string_view FullMessageName() {
+    return "stream.ScanTestCfg";
+  }
+  protected:
+  explicit ScanTestCfg(::google::protobuf::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::google::protobuf::Message::ClassData*GetClassData() const final;
+
+  ::google::protobuf::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDebugShapeFieldNumber = 1,
+    kShapeSizeFieldNumber = 2,
+    kShapeSizeMinFieldNumber = 3,
+    kShapeSizeMaxFieldNumber = 4,
+    kLaserPowerFieldNumber = 5,
+    kLaserPowerMinFieldNumber = 6,
+    kDefocusFieldNumber = 8,
+    kDefocusMinFieldNumber = 9,
+    kDefocusMaxFieldNumber = 10,
+    kLaserPowerMaxFieldNumber = 7,
+    kIsCycleFieldNumber = 11,
+    kIsAutoHeatingScannerFieldNumber = 15,
+    kCrossXFieldNumber = 12,
+    kCrossYFieldNumber = 13,
+    kZDistanceFieldNumber = 14,
+    kAutoHeatingScannerMinutesFieldNumber = 16,
+    kAutoHeatingScannerSizeFieldNumber = 17,
+    kAutoHeatingScannerSpeedFieldNumber = 18,
+    kMarkTestStartXFieldNumber = 19,
+    kMarkTestStartYFieldNumber = 20,
+    kMarkTestEndXFieldNumber = 21,
+    kMarkTestEndYFieldNumber = 22,
+  };
+  // int32 debugShape = 1;
+  void clear_debugshape() ;
+  ::int32_t debugshape() const;
+  void set_debugshape(::int32_t value);
+
+  private:
+  ::int32_t _internal_debugshape() const;
+  void _internal_set_debugshape(::int32_t value);
+
+  public:
+  // int32 shapeSize = 2;
+  void clear_shapesize() ;
+  ::int32_t shapesize() const;
+  void set_shapesize(::int32_t value);
+
+  private:
+  ::int32_t _internal_shapesize() const;
+  void _internal_set_shapesize(::int32_t value);
+
+  public:
+  // int32 shapeSizeMin = 3;
+  void clear_shapesizemin() ;
+  ::int32_t shapesizemin() const;
+  void set_shapesizemin(::int32_t value);
+
+  private:
+  ::int32_t _internal_shapesizemin() const;
+  void _internal_set_shapesizemin(::int32_t value);
+
+  public:
+  // int32 shape_size_max = 4;
+  void clear_shape_size_max() ;
+  ::int32_t shape_size_max() const;
+  void set_shape_size_max(::int32_t value);
+
+  private:
+  ::int32_t _internal_shape_size_max() const;
+  void _internal_set_shape_size_max(::int32_t value);
+
+  public:
+  // int32 laser_power = 5;
+  void clear_laser_power() ;
+  ::int32_t laser_power() const;
+  void set_laser_power(::int32_t value);
+
+  private:
+  ::int32_t _internal_laser_power() const;
+  void _internal_set_laser_power(::int32_t value);
+
+  public:
+  // int32 laser_power_min = 6;
+  void clear_laser_power_min() ;
+  ::int32_t laser_power_min() const;
+  void set_laser_power_min(::int32_t value);
+
+  private:
+  ::int32_t _internal_laser_power_min() const;
+  void _internal_set_laser_power_min(::int32_t value);
+
+  public:
+  // double defocus = 8;
+  void clear_defocus() ;
+  double defocus() const;
+  void set_defocus(double value);
+
+  private:
+  double _internal_defocus() const;
+  void _internal_set_defocus(double value);
+
+  public:
+  // double defocus_min = 9;
+  void clear_defocus_min() ;
+  double defocus_min() const;
+  void set_defocus_min(double value);
+
+  private:
+  double _internal_defocus_min() const;
+  void _internal_set_defocus_min(double value);
+
+  public:
+  // double defocus_max = 10;
+  void clear_defocus_max() ;
+  double defocus_max() const;
+  void set_defocus_max(double value);
+
+  private:
+  double _internal_defocus_max() const;
+  void _internal_set_defocus_max(double value);
+
+  public:
+  // int32 laser_power_max = 7;
+  void clear_laser_power_max() ;
+  ::int32_t laser_power_max() const;
+  void set_laser_power_max(::int32_t value);
+
+  private:
+  ::int32_t _internal_laser_power_max() const;
+  void _internal_set_laser_power_max(::int32_t value);
+
+  public:
+  // bool is_cycle = 11;
+  void clear_is_cycle() ;
+  bool is_cycle() const;
+  void set_is_cycle(bool value);
+
+  private:
+  bool _internal_is_cycle() const;
+  void _internal_set_is_cycle(bool value);
+
+  public:
+  // bool isAutoHeatingScanner = 15;
+  void clear_isautoheatingscanner() ;
+  bool isautoheatingscanner() const;
+  void set_isautoheatingscanner(bool value);
+
+  private:
+  bool _internal_isautoheatingscanner() const;
+  void _internal_set_isautoheatingscanner(bool value);
+
+  public:
+  // double cross_x = 12;
+  void clear_cross_x() ;
+  double cross_x() const;
+  void set_cross_x(double value);
+
+  private:
+  double _internal_cross_x() const;
+  void _internal_set_cross_x(double value);
+
+  public:
+  // double cross_y = 13;
+  void clear_cross_y() ;
+  double cross_y() const;
+  void set_cross_y(double value);
+
+  private:
+  double _internal_cross_y() const;
+  void _internal_set_cross_y(double value);
+
+  public:
+  // double z_distance = 14;
+  void clear_z_distance() ;
+  double z_distance() const;
+  void set_z_distance(double value);
+
+  private:
+  double _internal_z_distance() const;
+  void _internal_set_z_distance(double value);
+
+  public:
+  // uint32 autoHeatingScannerMinutes = 16;
+  void clear_autoheatingscannerminutes() ;
+  ::uint32_t autoheatingscannerminutes() const;
+  void set_autoheatingscannerminutes(::uint32_t value);
+
+  private:
+  ::uint32_t _internal_autoheatingscannerminutes() const;
+  void _internal_set_autoheatingscannerminutes(::uint32_t value);
+
+  public:
+  // uint32 autoHeatingScannerSize = 17;
+  void clear_autoheatingscannersize() ;
+  ::uint32_t autoheatingscannersize() const;
+  void set_autoheatingscannersize(::uint32_t value);
+
+  private:
+  ::uint32_t _internal_autoheatingscannersize() const;
+  void _internal_set_autoheatingscannersize(::uint32_t value);
+
+  public:
+  // double autoHeatingScannerSpeed = 18;
+  void clear_autoheatingscannerspeed() ;
+  double autoheatingscannerspeed() const;
+  void set_autoheatingscannerspeed(double value);
+
+  private:
+  double _internal_autoheatingscannerspeed() const;
+  void _internal_set_autoheatingscannerspeed(double value);
+
+  public:
+  // double mark_test_start_x = 19;
+  void clear_mark_test_start_x() ;
+  double mark_test_start_x() const;
+  void set_mark_test_start_x(double value);
+
+  private:
+  double _internal_mark_test_start_x() const;
+  void _internal_set_mark_test_start_x(double value);
+
+  public:
+  // double mark_test_start_y = 20;
+  void clear_mark_test_start_y() ;
+  double mark_test_start_y() const;
+  void set_mark_test_start_y(double value);
+
+  private:
+  double _internal_mark_test_start_y() const;
+  void _internal_set_mark_test_start_y(double value);
+
+  public:
+  // double mark_test_end_x = 21;
+  void clear_mark_test_end_x() ;
+  double mark_test_end_x() const;
+  void set_mark_test_end_x(double value);
+
+  private:
+  double _internal_mark_test_end_x() const;
+  void _internal_set_mark_test_end_x(double value);
+
+  public:
+  // double mark_test_end_y = 22;
+  void clear_mark_test_end_y() ;
+  double mark_test_end_y() const;
+  void set_mark_test_end_y(double value);
+
+  private:
+  double _internal_mark_test_end_y() const;
+  void _internal_set_mark_test_end_y(double value);
+
+  public:
+  // @@protoc_insertion_point(class_scope:stream.ScanTestCfg)
+ private:
+  class _Internal;
+
+  friend class ::google::protobuf::internal::TcParser;
+  static const ::google::protobuf::internal::TcParseTable<5, 22, 0, 0, 2> _table_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::int32_t debugshape_;
+    ::int32_t shapesize_;
+    ::int32_t shapesizemin_;
+    ::int32_t shape_size_max_;
+    ::int32_t laser_power_;
+    ::int32_t laser_power_min_;
+    double defocus_;
+    double defocus_min_;
+    double defocus_max_;
+    ::int32_t laser_power_max_;
+    bool is_cycle_;
+    bool isautoheatingscanner_;
+    double cross_x_;
+    double cross_y_;
+    double z_distance_;
+    ::uint32_t autoheatingscannerminutes_;
+    ::uint32_t autoheatingscannersize_;
+    double autoheatingscannerspeed_;
+    double mark_test_start_x_;
+    double mark_test_start_y_;
+    double mark_test_end_x_;
+    double mark_test_end_y_;
+    mutable ::google::protobuf::internal::CachedSize _cached_size_;
+    PROTOBUF_TSAN_DECLARE_MEMBER
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_stream_2eproto;
+};// -------------------------------------------------------------------
+
+class SkyWritingCfg final :
+    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:stream.SkyWritingCfg) */ {
+ public:
+  inline SkyWritingCfg() : SkyWritingCfg(nullptr) {}
+  ~SkyWritingCfg() override;
+  template<typename = void>
+  explicit PROTOBUF_CONSTEXPR SkyWritingCfg(::google::protobuf::internal::ConstantInitialized);
+
+  SkyWritingCfg(const SkyWritingCfg& from);
+  SkyWritingCfg(SkyWritingCfg&& from) noexcept
+    : SkyWritingCfg() {
+    *this = ::std::move(from);
+  }
+
+  inline SkyWritingCfg& operator=(const SkyWritingCfg& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SkyWritingCfg& operator=(SkyWritingCfg&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
+  }
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::google::protobuf::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::google::protobuf::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SkyWritingCfg& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SkyWritingCfg* internal_default_instance() {
+    return reinterpret_cast<const SkyWritingCfg*>(
+               &_SkyWritingCfg_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    18;
+
+  friend void swap(SkyWritingCfg& a, SkyWritingCfg& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SkyWritingCfg* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::google::protobuf::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SkyWritingCfg* other) {
+    if (other == this) return;
+    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SkyWritingCfg* New(::google::protobuf::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SkyWritingCfg>(arena);
+  }
+  using ::google::protobuf::Message::CopyFrom;
+  void CopyFrom(const SkyWritingCfg& from);
+  using ::google::protobuf::Message::MergeFrom;
+  void MergeFrom( const SkyWritingCfg& from) {
+    SkyWritingCfg::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  ::size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
+  ::uint8_t* _InternalSerialize(
+      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::google::protobuf::Arena* arena);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SkyWritingCfg* other);
+
+  private:
+  friend class ::google::protobuf::internal::AnyMetadata;
+  static ::absl::string_view FullMessageName() {
+    return "stream.SkyWritingCfg";
+  }
+  protected:
+  explicit SkyWritingCfg(::google::protobuf::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::google::protobuf::Message::ClassData*GetClassData() const final;
+
+  ::google::protobuf::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTimelagFieldNumber = 2,
+    kTimelagMinFieldNumber = 3,
+    kTimelagMaxFieldNumber = 4,
+    kIsEnableFieldNumber = 1,
+    kNprevFieldNumber = 8,
+    kLaserOnShiftFieldNumber = 5,
+    kLaserOnShiftMinFieldNumber = 6,
+    kLaserOnShiftMaxFieldNumber = 7,
+    kNprevMinFieldNumber = 9,
+    kNprevMaxFieldNumber = 10,
+    kNpostFieldNumber = 11,
+    kNpostMinFieldNumber = 12,
+    kNpostMaxFieldNumber = 13,
+    kModeFieldNumber = 14,
+    kLimiteFieldNumber = 15,
+    kLimiteMinFieldNumber = 16,
+    kLimiteMaxFieldNumber = 17,
+  };
+  // double timelag = 2;
+  void clear_timelag() ;
+  double timelag() const;
+  void set_timelag(double value);
+
+  private:
+  double _internal_timelag() const;
+  void _internal_set_timelag(double value);
+
+  public:
+  // double timelagMin = 3;
+  void clear_timelagmin() ;
+  double timelagmin() const;
+  void set_timelagmin(double value);
+
+  private:
+  double _internal_timelagmin() const;
+  void _internal_set_timelagmin(double value);
+
+  public:
+  // double timelagMax = 4;
+  void clear_timelagmax() ;
+  double timelagmax() const;
+  void set_timelagmax(double value);
+
+  private:
+  double _internal_timelagmax() const;
+  void _internal_set_timelagmax(double value);
+
+  public:
+  // bool isEnable = 1;
+  void clear_isenable() ;
+  bool isenable() const;
+  void set_isenable(bool value);
+
+  private:
+  bool _internal_isenable() const;
+  void _internal_set_isenable(bool value);
+
+  public:
+  // uint32 nprev = 8;
+  void clear_nprev() ;
+  ::uint32_t nprev() const;
+  void set_nprev(::uint32_t value);
+
+  private:
+  ::uint32_t _internal_nprev() const;
+  void _internal_set_nprev(::uint32_t value);
+
+  public:
+  // int64 laserOnShift = 5;
+  void clear_laseronshift() ;
+  ::int64_t laseronshift() const;
+  void set_laseronshift(::int64_t value);
+
+  private:
+  ::int64_t _internal_laseronshift() const;
+  void _internal_set_laseronshift(::int64_t value);
+
+  public:
+  // int64 laserOnShiftMin = 6;
+  void clear_laseronshiftmin() ;
+  ::int64_t laseronshiftmin() const;
+  void set_laseronshiftmin(::int64_t value);
+
+  private:
+  ::int64_t _internal_laseronshiftmin() const;
+  void _internal_set_laseronshiftmin(::int64_t value);
+
+  public:
+  // int64 laserOnShiftMax = 7;
+  void clear_laseronshiftmax() ;
+  ::int64_t laseronshiftmax() const;
+  void set_laseronshiftmax(::int64_t value);
+
+  private:
+  ::int64_t _internal_laseronshiftmax() const;
+  void _internal_set_laseronshiftmax(::int64_t value);
+
+  public:
+  // uint32 nprevMin = 9;
+  void clear_nprevmin() ;
+  ::uint32_t nprevmin() const;
+  void set_nprevmin(::uint32_t value);
+
+  private:
+  ::uint32_t _internal_nprevmin() const;
+  void _internal_set_nprevmin(::uint32_t value);
+
+  public:
+  // uint32 nprevMax = 10;
+  void clear_nprevmax() ;
+  ::uint32_t nprevmax() const;
+  void set_nprevmax(::uint32_t value);
+
+  private:
+  ::uint32_t _internal_nprevmax() const;
+  void _internal_set_nprevmax(::uint32_t value);
+
+  public:
+  // uint32 npost = 11;
+  void clear_npost() ;
+  ::uint32_t npost() const;
+  void set_npost(::uint32_t value);
+
+  private:
+  ::uint32_t _internal_npost() const;
+  void _internal_set_npost(::uint32_t value);
+
+  public:
+  // uint32 npostMin = 12;
+  void clear_npostmin() ;
+  ::uint32_t npostmin() const;
+  void set_npostmin(::uint32_t value);
+
+  private:
+  ::uint32_t _internal_npostmin() const;
+  void _internal_set_npostmin(::uint32_t value);
+
+  public:
+  // uint32 npostMax = 13;
+  void clear_npostmax() ;
+  ::uint32_t npostmax() const;
+  void set_npostmax(::uint32_t value);
+
+  private:
+  ::uint32_t _internal_npostmax() const;
+  void _internal_set_npostmax(::uint32_t value);
+
+  public:
+  // int32 mode = 14;
+  void clear_mode() ;
+  ::int32_t mode() const;
+  void set_mode(::int32_t value);
+
+  private:
+  ::int32_t _internal_mode() const;
+  void _internal_set_mode(::int32_t value);
+
+  public:
+  // double limite = 15;
+  void clear_limite() ;
+  double limite() const;
+  void set_limite(double value);
+
+  private:
+  double _internal_limite() const;
+  void _internal_set_limite(double value);
+
+  public:
+  // double limiteMin = 16;
+  void clear_limitemin() ;
+  double limitemin() const;
+  void set_limitemin(double value);
+
+  private:
+  double _internal_limitemin() const;
+  void _internal_set_limitemin(double value);
+
+  public:
+  // double limiteMax = 17;
+  void clear_limitemax() ;
+  double limitemax() const;
+  void set_limitemax(double value);
+
+  private:
+  double _internal_limitemax() const;
+  void _internal_set_limitemax(double value);
+
+  public:
+  // @@protoc_insertion_point(class_scope:stream.SkyWritingCfg)
+ private:
+  class _Internal;
+
+  friend class ::google::protobuf::internal::TcParser;
+  static const ::google::protobuf::internal::TcParseTable<5, 17, 0, 0, 2> _table_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    double timelag_;
+    double timelagmin_;
+    double timelagmax_;
+    bool isenable_;
+    ::uint32_t nprev_;
+    ::int64_t laseronshift_;
+    ::int64_t laseronshiftmin_;
+    ::int64_t laseronshiftmax_;
+    ::uint32_t nprevmin_;
+    ::uint32_t nprevmax_;
+    ::uint32_t npost_;
+    ::uint32_t npostmin_;
+    ::uint32_t npostmax_;
+    ::int32_t mode_;
+    double limite_;
+    double limitemin_;
+    double limitemax_;
+    mutable ::google::protobuf::internal::CachedSize _cached_size_;
+    PROTOBUF_TSAN_DECLARE_MEMBER
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_stream_2eproto;
+};// -------------------------------------------------------------------
+
+class PowerCompensate final :
+    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:stream.PowerCompensate) */ {
+ public:
+  inline PowerCompensate() : PowerCompensate(nullptr) {}
+  ~PowerCompensate() override;
+  template<typename = void>
+  explicit PROTOBUF_CONSTEXPR PowerCompensate(::google::protobuf::internal::ConstantInitialized);
+
+  PowerCompensate(const PowerCompensate& from);
+  PowerCompensate(PowerCompensate&& from) noexcept
+    : PowerCompensate() {
+    *this = ::std::move(from);
+  }
+
+  inline PowerCompensate& operator=(const PowerCompensate& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline PowerCompensate& operator=(PowerCompensate&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
+  }
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::google::protobuf::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::google::protobuf::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const PowerCompensate& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const PowerCompensate* internal_default_instance() {
+    return reinterpret_cast<const PowerCompensate*>(
+               &_PowerCompensate_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    19;
+
+  friend void swap(PowerCompensate& a, PowerCompensate& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(PowerCompensate* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::google::protobuf::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(PowerCompensate* other) {
+    if (other == this) return;
+    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  PowerCompensate* New(::google::protobuf::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<PowerCompensate>(arena);
+  }
+  using ::google::protobuf::Message::CopyFrom;
+  void CopyFrom(const PowerCompensate& from);
+  using ::google::protobuf::Message::MergeFrom;
+  void MergeFrom( const PowerCompensate& from) {
+    PowerCompensate::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  ::size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
+  ::uint8_t* _InternalSerialize(
+      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::google::protobuf::Arena* arena);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(PowerCompensate* other);
+
+  private:
+  friend class ::google::protobuf::internal::AnyMetadata;
+  static ::absl::string_view FullMessageName() {
+    return "stream.PowerCompensate";
+  }
+  protected:
+  explicit PowerCompensate(::google::protobuf::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::google::protobuf::Message::ClassData*GetClassData() const final;
+
+  ::google::protobuf::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kCnoFieldNumber = 1,
+    kPercentFieldNumber = 2,
+    kValueFieldNumber = 3,
+    kValueMinFieldNumber = 4,
+    kValueMaxFieldNumber = 5,
+  };
+  // int32 cno = 1;
+  void clear_cno() ;
+  ::int32_t cno() const;
+  void set_cno(::int32_t value);
+
+  private:
+  ::int32_t _internal_cno() const;
+  void _internal_set_cno(::int32_t value);
+
+  public:
+  // int32 percent = 2;
+  void clear_percent() ;
+  ::int32_t percent() const;
+  void set_percent(::int32_t value);
+
+  private:
+  ::int32_t _internal_percent() const;
+  void _internal_set_percent(::int32_t value);
+
+  public:
+  // float value = 3;
+  void clear_value() ;
+  float value() const;
+  void set_value(float value);
+
+  private:
+  float _internal_value() const;
+  void _internal_set_value(float value);
+
+  public:
+  // float value_min = 4;
+  void clear_value_min() ;
+  float value_min() const;
+  void set_value_min(float value);
+
+  private:
+  float _internal_value_min() const;
+  void _internal_set_value_min(float value);
+
+  public:
+  // float value_max = 5;
+  void clear_value_max() ;
+  float value_max() const;
+  void set_value_max(float value);
+
+  private:
+  float _internal_value_max() const;
+  void _internal_set_value_max(float value);
+
+  public:
+  // @@protoc_insertion_point(class_scope:stream.PowerCompensate)
+ private:
+  class _Internal;
+
+  friend class ::google::protobuf::internal::TcParser;
+  static const ::google::protobuf::internal::TcParseTable<3, 5, 0, 0, 2> _table_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::int32_t cno_;
+    ::int32_t percent_;
+    float value_;
+    float value_min_;
+    float value_max_;
+    mutable ::google::protobuf::internal::CachedSize _cached_size_;
+    PROTOBUF_TSAN_DECLARE_MEMBER
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_stream_2eproto;
+};// -------------------------------------------------------------------
+
+class TimePowerCompensate final :
+    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:stream.TimePowerCompensate) */ {
+ public:
+  inline TimePowerCompensate() : TimePowerCompensate(nullptr) {}
+  ~TimePowerCompensate() override;
+  template<typename = void>
+  explicit PROTOBUF_CONSTEXPR TimePowerCompensate(::google::protobuf::internal::ConstantInitialized);
+
+  TimePowerCompensate(const TimePowerCompensate& from);
+  TimePowerCompensate(TimePowerCompensate&& from) noexcept
+    : TimePowerCompensate() {
+    *this = ::std::move(from);
+  }
+
+  inline TimePowerCompensate& operator=(const TimePowerCompensate& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline TimePowerCompensate& operator=(TimePowerCompensate&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
+  }
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::google::protobuf::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::google::protobuf::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const TimePowerCompensate& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const TimePowerCompensate* internal_default_instance() {
+    return reinterpret_cast<const TimePowerCompensate*>(
+               &_TimePowerCompensate_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    20;
+
+  friend void swap(TimePowerCompensate& a, TimePowerCompensate& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(TimePowerCompensate* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::google::protobuf::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(TimePowerCompensate* other) {
+    if (other == this) return;
+    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  TimePowerCompensate* New(::google::protobuf::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<TimePowerCompensate>(arena);
+  }
+  using ::google::protobuf::Message::CopyFrom;
+  void CopyFrom(const TimePowerCompensate& from);
+  using ::google::protobuf::Message::MergeFrom;
+  void MergeFrom( const TimePowerCompensate& from) {
+    TimePowerCompensate::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  ::size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
+  ::uint8_t* _InternalSerialize(
+      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::google::protobuf::Arena* arena);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(TimePowerCompensate* other);
+
+  private:
+  friend class ::google::protobuf::internal::AnyMetadata;
+  static ::absl::string_view FullMessageName() {
+    return "stream.TimePowerCompensate";
+  }
+  protected:
+  explicit TimePowerCompensate(::google::protobuf::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::google::protobuf::Message::ClassData*GetClassData() const final;
+
+  ::google::protobuf::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kIdFieldNumber = 1,
+    kCnoFieldNumber = 2,
+    kStartMinuteFieldNumber = 3,
+    kEndMinuteFieldNumber = 4,
+    kCompensateFieldNumber = 5,
+  };
+  // int32 id = 1;
+  void clear_id() ;
+  ::int32_t id() const;
+  void set_id(::int32_t value);
+
+  private:
+  ::int32_t _internal_id() const;
+  void _internal_set_id(::int32_t value);
+
+  public:
+  // int32 cno = 2;
+  void clear_cno() ;
+  ::int32_t cno() const;
+  void set_cno(::int32_t value);
+
+  private:
+  ::int32_t _internal_cno() const;
+  void _internal_set_cno(::int32_t value);
+
+  public:
+  // uint32 startMinute = 3;
+  void clear_startminute() ;
+  ::uint32_t startminute() const;
+  void set_startminute(::uint32_t value);
+
+  private:
+  ::uint32_t _internal_startminute() const;
+  void _internal_set_startminute(::uint32_t value);
+
+  public:
+  // uint32 endMinute = 4;
+  void clear_endminute() ;
+  ::uint32_t endminute() const;
+  void set_endminute(::uint32_t value);
+
+  private:
+  ::uint32_t _internal_endminute() const;
+  void _internal_set_endminute(::uint32_t value);
+
+  public:
+  // float compensate = 5;
+  void clear_compensate() ;
+  float compensate() const;
+  void set_compensate(float value);
+
+  private:
+  float _internal_compensate() const;
+  void _internal_set_compensate(float value);
+
+  public:
+  // @@protoc_insertion_point(class_scope:stream.TimePowerCompensate)
+ private:
+  class _Internal;
+
+  friend class ::google::protobuf::internal::TcParser;
+  static const ::google::protobuf::internal::TcParseTable<3, 5, 0, 0, 2> _table_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::int32_t id_;
+    ::int32_t cno_;
+    ::uint32_t startminute_;
+    ::uint32_t endminute_;
+    float compensate_;
+    mutable ::google::protobuf::internal::CachedSize _cached_size_;
+    PROTOBUF_TSAN_DECLARE_MEMBER
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_stream_2eproto;
 };
 
 // ===================================================================
@@ -2873,6 +5962,240 @@ inline void ParamInfo::_internal_set_powder(float value) {
   _impl_.powder_ = value;
 }
 
+// int32 seqNo = 11;
+inline void ParamInfo::clear_seqno() {
+  _impl_.seqno_ = 0;
+}
+inline ::int32_t ParamInfo::seqno() const {
+  // @@protoc_insertion_point(field_get:stream.ParamInfo.seqNo)
+  return _internal_seqno();
+}
+inline void ParamInfo::set_seqno(::int32_t value) {
+  _internal_set_seqno(value);
+  // @@protoc_insertion_point(field_set:stream.ParamInfo.seqNo)
+}
+inline ::int32_t ParamInfo::_internal_seqno() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.seqno_;
+}
+inline void ParamInfo::_internal_set_seqno(::int32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.seqno_ = value;
+}
+
+// int32 controlNo = 12;
+inline void ParamInfo::clear_controlno() {
+  _impl_.controlno_ = 0;
+}
+inline ::int32_t ParamInfo::controlno() const {
+  // @@protoc_insertion_point(field_get:stream.ParamInfo.controlNo)
+  return _internal_controlno();
+}
+inline void ParamInfo::set_controlno(::int32_t value) {
+  _internal_set_controlno(value);
+  // @@protoc_insertion_point(field_set:stream.ParamInfo.controlNo)
+}
+inline ::int32_t ParamInfo::_internal_controlno() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.controlno_;
+}
+inline void ParamInfo::_internal_set_controlno(::int32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.controlno_ = value;
+}
+
+// int32 serialNo = 13;
+inline void ParamInfo::clear_serialno() {
+  _impl_.serialno_ = 0;
+}
+inline ::int32_t ParamInfo::serialno() const {
+  // @@protoc_insertion_point(field_get:stream.ParamInfo.serialNo)
+  return _internal_serialno();
+}
+inline void ParamInfo::set_serialno(::int32_t value) {
+  _internal_set_serialno(value);
+  // @@protoc_insertion_point(field_set:stream.ParamInfo.serialNo)
+}
+inline ::int32_t ParamInfo::_internal_serialno() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.serialno_;
+}
+inline void ParamInfo::_internal_set_serialno(::int32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.serialno_ = value;
+}
+
+// int32 controlType = 14;
+inline void ParamInfo::clear_controltype() {
+  _impl_.controltype_ = 0;
+}
+inline ::int32_t ParamInfo::controltype() const {
+  // @@protoc_insertion_point(field_get:stream.ParamInfo.controlType)
+  return _internal_controltype();
+}
+inline void ParamInfo::set_controltype(::int32_t value) {
+  _internal_set_controltype(value);
+  // @@protoc_insertion_point(field_set:stream.ParamInfo.controlType)
+}
+inline ::int32_t ParamInfo::_internal_controltype() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.controltype_;
+}
+inline void ParamInfo::_internal_set_controltype(::int32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.controltype_ = value;
+}
+
+// bytes cardName = 15;
+inline void ParamInfo::clear_cardname() {
+  _impl_.cardname_.ClearToEmpty();
+}
+inline const std::string& ParamInfo::cardname() const {
+  // @@protoc_insertion_point(field_get:stream.ParamInfo.cardName)
+  return _internal_cardname();
+}
+template <typename Arg_, typename... Args_>
+inline PROTOBUF_ALWAYS_INLINE void ParamInfo::set_cardname(Arg_&& arg,
+                                                     Args_... args) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.cardname_.SetBytes(static_cast<Arg_&&>(arg), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:stream.ParamInfo.cardName)
+}
+inline std::string* ParamInfo::mutable_cardname() {
+  std::string* _s = _internal_mutable_cardname();
+  // @@protoc_insertion_point(field_mutable:stream.ParamInfo.cardName)
+  return _s;
+}
+inline const std::string& ParamInfo::_internal_cardname() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.cardname_.Get();
+}
+inline void ParamInfo::_internal_set_cardname(const std::string& value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.cardname_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ParamInfo::_internal_mutable_cardname() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  return _impl_.cardname_.Mutable( GetArenaForAllocation());
+}
+inline std::string* ParamInfo::release_cardname() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  // @@protoc_insertion_point(field_release:stream.ParamInfo.cardName)
+  return _impl_.cardname_.Release();
+}
+inline void ParamInfo::set_allocated_cardname(std::string* value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  _impl_.cardname_.SetAllocated(value, GetArenaForAllocation());
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        if (_impl_.cardname_.IsDefault()) {
+          _impl_.cardname_.Set("", GetArenaForAllocation());
+        }
+  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:stream.ParamInfo.cardName)
+}
+
+// bytes cardIP = 16;
+inline void ParamInfo::clear_cardip() {
+  _impl_.cardip_.ClearToEmpty();
+}
+inline const std::string& ParamInfo::cardip() const {
+  // @@protoc_insertion_point(field_get:stream.ParamInfo.cardIP)
+  return _internal_cardip();
+}
+template <typename Arg_, typename... Args_>
+inline PROTOBUF_ALWAYS_INLINE void ParamInfo::set_cardip(Arg_&& arg,
+                                                     Args_... args) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.cardip_.SetBytes(static_cast<Arg_&&>(arg), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:stream.ParamInfo.cardIP)
+}
+inline std::string* ParamInfo::mutable_cardip() {
+  std::string* _s = _internal_mutable_cardip();
+  // @@protoc_insertion_point(field_mutable:stream.ParamInfo.cardIP)
+  return _s;
+}
+inline const std::string& ParamInfo::_internal_cardip() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.cardip_.Get();
+}
+inline void ParamInfo::_internal_set_cardip(const std::string& value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.cardip_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ParamInfo::_internal_mutable_cardip() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  return _impl_.cardip_.Mutable( GetArenaForAllocation());
+}
+inline std::string* ParamInfo::release_cardip() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  // @@protoc_insertion_point(field_release:stream.ParamInfo.cardIP)
+  return _impl_.cardip_.Release();
+}
+inline void ParamInfo::set_allocated_cardip(std::string* value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  _impl_.cardip_.SetAllocated(value, GetArenaForAllocation());
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        if (_impl_.cardip_.IsDefault()) {
+          _impl_.cardip_.Set("", GetArenaForAllocation());
+        }
+  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:stream.ParamInfo.cardIP)
+}
+
+// bool hadAssign = 17;
+inline void ParamInfo::clear_hadassign() {
+  _impl_.hadassign_ = false;
+}
+inline bool ParamInfo::hadassign() const {
+  // @@protoc_insertion_point(field_get:stream.ParamInfo.hadAssign)
+  return _internal_hadassign();
+}
+inline void ParamInfo::set_hadassign(bool value) {
+  _internal_set_hadassign(value);
+  // @@protoc_insertion_point(field_set:stream.ParamInfo.hadAssign)
+}
+inline bool ParamInfo::_internal_hadassign() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.hadassign_;
+}
+inline void ParamInfo::_internal_set_hadassign(bool value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.hadassign_ = value;
+}
+
+// bool hadMatch = 18;
+inline void ParamInfo::clear_hadmatch() {
+  _impl_.hadmatch_ = false;
+}
+inline bool ParamInfo::hadmatch() const {
+  // @@protoc_insertion_point(field_get:stream.ParamInfo.hadMatch)
+  return _internal_hadmatch();
+}
+inline void ParamInfo::set_hadmatch(bool value) {
+  _internal_set_hadmatch(value);
+  // @@protoc_insertion_point(field_set:stream.ParamInfo.hadMatch)
+}
+inline bool ParamInfo::_internal_hadmatch() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.hadmatch_;
+}
+inline void ParamInfo::_internal_set_hadmatch(bool value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.hadmatch_ = value;
+}
+
 // -------------------------------------------------------------------
 
 // RequestInfo
@@ -3966,6 +7289,3574 @@ inline void ComResponce::set_allocated_data(std::string* value) {
   // @@protoc_insertion_point(field_set_allocated:stream.ComResponce.data)
 }
 
+// -------------------------------------------------------------------
+
+// ScannerCrtlCfgResp
+
+// repeated .stream.ScannerCrtlCfgData scannerCfg = 1;
+inline int ScannerCrtlCfgResp::_internal_scannercfg_size() const {
+  return _internal_scannercfg().size();
+}
+inline int ScannerCrtlCfgResp::scannercfg_size() const {
+  return _internal_scannercfg_size();
+}
+inline void ScannerCrtlCfgResp::clear_scannercfg() {
+  _internal_mutable_scannercfg()->Clear();
+}
+inline ::stream::ScannerCrtlCfgData* ScannerCrtlCfgResp::mutable_scannercfg(int index) {
+  // @@protoc_insertion_point(field_mutable:stream.ScannerCrtlCfgResp.scannerCfg)
+  return _internal_mutable_scannercfg()->Mutable(index);
+}
+inline ::google::protobuf::RepeatedPtrField< ::stream::ScannerCrtlCfgData >*
+ScannerCrtlCfgResp::mutable_scannercfg() {
+  // @@protoc_insertion_point(field_mutable_list:stream.ScannerCrtlCfgResp.scannerCfg)
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  return _internal_mutable_scannercfg();
+}
+inline const ::stream::ScannerCrtlCfgData& ScannerCrtlCfgResp::scannercfg(int index) const {
+  // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgResp.scannerCfg)
+    return _internal_scannercfg().Get(index);
+}
+inline ::stream::ScannerCrtlCfgData* ScannerCrtlCfgResp::add_scannercfg() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ::stream::ScannerCrtlCfgData* _add = _internal_mutable_scannercfg()->Add();
+  // @@protoc_insertion_point(field_add:stream.ScannerCrtlCfgResp.scannerCfg)
+  return _add;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::stream::ScannerCrtlCfgData >&
+ScannerCrtlCfgResp::scannercfg() const {
+  // @@protoc_insertion_point(field_list:stream.ScannerCrtlCfgResp.scannerCfg)
+  return _internal_scannercfg();
+}
+inline const ::google::protobuf::RepeatedPtrField<::stream::ScannerCrtlCfgData>&
+ScannerCrtlCfgResp::_internal_scannercfg() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.scannercfg_;
+}
+inline ::google::protobuf::RepeatedPtrField<::stream::ScannerCrtlCfgData>*
+ScannerCrtlCfgResp::_internal_mutable_scannercfg() {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return &_impl_.scannercfg_;
+}
+
+// -------------------------------------------------------------------
+
+// ScannerCrtlCfgData
+
+// int32 seqNo = 1;
+inline void ScannerCrtlCfgData::clear_seqno() {
+  _impl_.seqno_ = 0;
+}
+inline ::int32_t ScannerCrtlCfgData::seqno() const {
+  // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.seqNo)
+  return _internal_seqno();
+}
+inline void ScannerCrtlCfgData::set_seqno(::int32_t value) {
+  _internal_set_seqno(value);
+  // @@protoc_insertion_point(field_set:stream.ScannerCrtlCfgData.seqNo)
+}
+inline ::int32_t ScannerCrtlCfgData::_internal_seqno() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.seqno_;
+}
+inline void ScannerCrtlCfgData::_internal_set_seqno(::int32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.seqno_ = value;
+}
+
+// repeated .stream.FixPointData fixPointData = 2;
+inline int ScannerCrtlCfgData::_internal_fixpointdata_size() const {
+  return _internal_fixpointdata().size();
+}
+inline int ScannerCrtlCfgData::fixpointdata_size() const {
+  return _internal_fixpointdata_size();
+}
+inline void ScannerCrtlCfgData::clear_fixpointdata() {
+  _internal_mutable_fixpointdata()->Clear();
+}
+inline ::stream::FixPointData* ScannerCrtlCfgData::mutable_fixpointdata(int index) {
+  // @@protoc_insertion_point(field_mutable:stream.ScannerCrtlCfgData.fixPointData)
+  return _internal_mutable_fixpointdata()->Mutable(index);
+}
+inline ::google::protobuf::RepeatedPtrField< ::stream::FixPointData >*
+ScannerCrtlCfgData::mutable_fixpointdata() {
+  // @@protoc_insertion_point(field_mutable_list:stream.ScannerCrtlCfgData.fixPointData)
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  return _internal_mutable_fixpointdata();
+}
+inline const ::stream::FixPointData& ScannerCrtlCfgData::fixpointdata(int index) const {
+  // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.fixPointData)
+    return _internal_fixpointdata().Get(index);
+}
+inline ::stream::FixPointData* ScannerCrtlCfgData::add_fixpointdata() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ::stream::FixPointData* _add = _internal_mutable_fixpointdata()->Add();
+  // @@protoc_insertion_point(field_add:stream.ScannerCrtlCfgData.fixPointData)
+  return _add;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::stream::FixPointData >&
+ScannerCrtlCfgData::fixpointdata() const {
+  // @@protoc_insertion_point(field_list:stream.ScannerCrtlCfgData.fixPointData)
+  return _internal_fixpointdata();
+}
+inline const ::google::protobuf::RepeatedPtrField<::stream::FixPointData>&
+ScannerCrtlCfgData::_internal_fixpointdata() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.fixpointdata_;
+}
+inline ::google::protobuf::RepeatedPtrField<::stream::FixPointData>*
+ScannerCrtlCfgData::_internal_mutable_fixpointdata() {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return &_impl_.fixpointdata_;
+}
+
+// .stream.ScanParamCfg scanParamCfg = 3;
+inline bool ScannerCrtlCfgData::has_scanparamcfg() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.scanparamcfg_ != nullptr);
+  return value;
+}
+inline void ScannerCrtlCfgData::clear_scanparamcfg() {
+  if (_impl_.scanparamcfg_ != nullptr) _impl_.scanparamcfg_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const ::stream::ScanParamCfg& ScannerCrtlCfgData::_internal_scanparamcfg() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  const ::stream::ScanParamCfg* p = _impl_.scanparamcfg_;
+  return p != nullptr ? *p : reinterpret_cast<const ::stream::ScanParamCfg&>(::stream::_ScanParamCfg_default_instance_);
+}
+inline const ::stream::ScanParamCfg& ScannerCrtlCfgData::scanparamcfg() const {
+  // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.scanParamCfg)
+  return _internal_scanparamcfg();
+}
+inline void ScannerCrtlCfgData::unsafe_arena_set_allocated_scanparamcfg(::stream::ScanParamCfg* value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.scanparamcfg_);
+  }
+  _impl_.scanparamcfg_ = reinterpret_cast<::stream::ScanParamCfg*>(value);
+  if (value != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:stream.ScannerCrtlCfgData.scanParamCfg)
+}
+inline ::stream::ScanParamCfg* ScannerCrtlCfgData::release_scanparamcfg() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::stream::ScanParamCfg* released = _impl_.scanparamcfg_;
+  _impl_.scanparamcfg_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
+  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
+  if (GetArenaForAllocation() == nullptr) {
+    delete old;
+  }
+#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return released;
+}
+inline ::stream::ScanParamCfg* ScannerCrtlCfgData::unsafe_arena_release_scanparamcfg() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  // @@protoc_insertion_point(field_release:stream.ScannerCrtlCfgData.scanParamCfg)
+
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::stream::ScanParamCfg* temp = _impl_.scanparamcfg_;
+  _impl_.scanparamcfg_ = nullptr;
+  return temp;
+}
+inline ::stream::ScanParamCfg* ScannerCrtlCfgData::_internal_mutable_scanparamcfg() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  _impl_._has_bits_[0] |= 0x00000001u;
+  if (_impl_.scanparamcfg_ == nullptr) {
+    auto* p = CreateMaybeMessage<::stream::ScanParamCfg>(GetArenaForAllocation());
+    _impl_.scanparamcfg_ = reinterpret_cast<::stream::ScanParamCfg*>(p);
+  }
+  return _impl_.scanparamcfg_;
+}
+inline ::stream::ScanParamCfg* ScannerCrtlCfgData::mutable_scanparamcfg() {
+  ::stream::ScanParamCfg* _msg = _internal_mutable_scanparamcfg();
+  // @@protoc_insertion_point(field_mutable:stream.ScannerCrtlCfgData.scanParamCfg)
+  return _msg;
+}
+inline void ScannerCrtlCfgData::set_allocated_scanparamcfg(::stream::ScanParamCfg* value) {
+  ::google::protobuf::Arena* message_arena = GetArenaForAllocation();
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  if (message_arena == nullptr) {
+    delete reinterpret_cast<::stream::ScanParamCfg*>(_impl_.scanparamcfg_);
+  }
+
+  if (value != nullptr) {
+    ::google::protobuf::Arena* submessage_arena =
+        ::google::protobuf::Arena::InternalGetOwningArena(reinterpret_cast<::stream::ScanParamCfg*>(value));
+    if (message_arena != submessage_arena) {
+      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+
+  _impl_.scanparamcfg_ = reinterpret_cast<::stream::ScanParamCfg*>(value);
+  // @@protoc_insertion_point(field_set_allocated:stream.ScannerCrtlCfgData.scanParamCfg)
+}
+
+// .stream.ScanParamCfg hatchingParams = 4;
+inline bool ScannerCrtlCfgData::has_hatchingparams() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.hatchingparams_ != nullptr);
+  return value;
+}
+inline void ScannerCrtlCfgData::clear_hatchingparams() {
+  if (_impl_.hatchingparams_ != nullptr) _impl_.hatchingparams_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::stream::ScanParamCfg& ScannerCrtlCfgData::_internal_hatchingparams() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  const ::stream::ScanParamCfg* p = _impl_.hatchingparams_;
+  return p != nullptr ? *p : reinterpret_cast<const ::stream::ScanParamCfg&>(::stream::_ScanParamCfg_default_instance_);
+}
+inline const ::stream::ScanParamCfg& ScannerCrtlCfgData::hatchingparams() const {
+  // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.hatchingParams)
+  return _internal_hatchingparams();
+}
+inline void ScannerCrtlCfgData::unsafe_arena_set_allocated_hatchingparams(::stream::ScanParamCfg* value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.hatchingparams_);
+  }
+  _impl_.hatchingparams_ = reinterpret_cast<::stream::ScanParamCfg*>(value);
+  if (value != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:stream.ScannerCrtlCfgData.hatchingParams)
+}
+inline ::stream::ScanParamCfg* ScannerCrtlCfgData::release_hatchingparams() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::stream::ScanParamCfg* released = _impl_.hatchingparams_;
+  _impl_.hatchingparams_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
+  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
+  if (GetArenaForAllocation() == nullptr) {
+    delete old;
+  }
+#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return released;
+}
+inline ::stream::ScanParamCfg* ScannerCrtlCfgData::unsafe_arena_release_hatchingparams() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  // @@protoc_insertion_point(field_release:stream.ScannerCrtlCfgData.hatchingParams)
+
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::stream::ScanParamCfg* temp = _impl_.hatchingparams_;
+  _impl_.hatchingparams_ = nullptr;
+  return temp;
+}
+inline ::stream::ScanParamCfg* ScannerCrtlCfgData::_internal_mutable_hatchingparams() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.hatchingparams_ == nullptr) {
+    auto* p = CreateMaybeMessage<::stream::ScanParamCfg>(GetArenaForAllocation());
+    _impl_.hatchingparams_ = reinterpret_cast<::stream::ScanParamCfg*>(p);
+  }
+  return _impl_.hatchingparams_;
+}
+inline ::stream::ScanParamCfg* ScannerCrtlCfgData::mutable_hatchingparams() {
+  ::stream::ScanParamCfg* _msg = _internal_mutable_hatchingparams();
+  // @@protoc_insertion_point(field_mutable:stream.ScannerCrtlCfgData.hatchingParams)
+  return _msg;
+}
+inline void ScannerCrtlCfgData::set_allocated_hatchingparams(::stream::ScanParamCfg* value) {
+  ::google::protobuf::Arena* message_arena = GetArenaForAllocation();
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  if (message_arena == nullptr) {
+    delete reinterpret_cast<::stream::ScanParamCfg*>(_impl_.hatchingparams_);
+  }
+
+  if (value != nullptr) {
+    ::google::protobuf::Arena* submessage_arena =
+        ::google::protobuf::Arena::InternalGetOwningArena(reinterpret_cast<::stream::ScanParamCfg*>(value));
+    if (message_arena != submessage_arena) {
+      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+
+  _impl_.hatchingparams_ = reinterpret_cast<::stream::ScanParamCfg*>(value);
+  // @@protoc_insertion_point(field_set_allocated:stream.ScannerCrtlCfgData.hatchingParams)
+}
+
+// .stream.ScanParamCfg borderParams = 5;
+inline bool ScannerCrtlCfgData::has_borderparams() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.borderparams_ != nullptr);
+  return value;
+}
+inline void ScannerCrtlCfgData::clear_borderparams() {
+  if (_impl_.borderparams_ != nullptr) _impl_.borderparams_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const ::stream::ScanParamCfg& ScannerCrtlCfgData::_internal_borderparams() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  const ::stream::ScanParamCfg* p = _impl_.borderparams_;
+  return p != nullptr ? *p : reinterpret_cast<const ::stream::ScanParamCfg&>(::stream::_ScanParamCfg_default_instance_);
+}
+inline const ::stream::ScanParamCfg& ScannerCrtlCfgData::borderparams() const {
+  // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.borderParams)
+  return _internal_borderparams();
+}
+inline void ScannerCrtlCfgData::unsafe_arena_set_allocated_borderparams(::stream::ScanParamCfg* value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.borderparams_);
+  }
+  _impl_.borderparams_ = reinterpret_cast<::stream::ScanParamCfg*>(value);
+  if (value != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:stream.ScannerCrtlCfgData.borderParams)
+}
+inline ::stream::ScanParamCfg* ScannerCrtlCfgData::release_borderparams() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::stream::ScanParamCfg* released = _impl_.borderparams_;
+  _impl_.borderparams_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
+  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
+  if (GetArenaForAllocation() == nullptr) {
+    delete old;
+  }
+#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return released;
+}
+inline ::stream::ScanParamCfg* ScannerCrtlCfgData::unsafe_arena_release_borderparams() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  // @@protoc_insertion_point(field_release:stream.ScannerCrtlCfgData.borderParams)
+
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::stream::ScanParamCfg* temp = _impl_.borderparams_;
+  _impl_.borderparams_ = nullptr;
+  return temp;
+}
+inline ::stream::ScanParamCfg* ScannerCrtlCfgData::_internal_mutable_borderparams() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  _impl_._has_bits_[0] |= 0x00000004u;
+  if (_impl_.borderparams_ == nullptr) {
+    auto* p = CreateMaybeMessage<::stream::ScanParamCfg>(GetArenaForAllocation());
+    _impl_.borderparams_ = reinterpret_cast<::stream::ScanParamCfg*>(p);
+  }
+  return _impl_.borderparams_;
+}
+inline ::stream::ScanParamCfg* ScannerCrtlCfgData::mutable_borderparams() {
+  ::stream::ScanParamCfg* _msg = _internal_mutable_borderparams();
+  // @@protoc_insertion_point(field_mutable:stream.ScannerCrtlCfgData.borderParams)
+  return _msg;
+}
+inline void ScannerCrtlCfgData::set_allocated_borderparams(::stream::ScanParamCfg* value) {
+  ::google::protobuf::Arena* message_arena = GetArenaForAllocation();
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  if (message_arena == nullptr) {
+    delete reinterpret_cast<::stream::ScanParamCfg*>(_impl_.borderparams_);
+  }
+
+  if (value != nullptr) {
+    ::google::protobuf::Arena* submessage_arena =
+        ::google::protobuf::Arena::InternalGetOwningArena(reinterpret_cast<::stream::ScanParamCfg*>(value));
+    if (message_arena != submessage_arena) {
+      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+
+  _impl_.borderparams_ = reinterpret_cast<::stream::ScanParamCfg*>(value);
+  // @@protoc_insertion_point(field_set_allocated:stream.ScannerCrtlCfgData.borderParams)
+}
+
+// .stream.ScanParamCfg supportParams = 6;
+inline bool ScannerCrtlCfgData::has_supportparams() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.supportparams_ != nullptr);
+  return value;
+}
+inline void ScannerCrtlCfgData::clear_supportparams() {
+  if (_impl_.supportparams_ != nullptr) _impl_.supportparams_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const ::stream::ScanParamCfg& ScannerCrtlCfgData::_internal_supportparams() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  const ::stream::ScanParamCfg* p = _impl_.supportparams_;
+  return p != nullptr ? *p : reinterpret_cast<const ::stream::ScanParamCfg&>(::stream::_ScanParamCfg_default_instance_);
+}
+inline const ::stream::ScanParamCfg& ScannerCrtlCfgData::supportparams() const {
+  // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.supportParams)
+  return _internal_supportparams();
+}
+inline void ScannerCrtlCfgData::unsafe_arena_set_allocated_supportparams(::stream::ScanParamCfg* value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.supportparams_);
+  }
+  _impl_.supportparams_ = reinterpret_cast<::stream::ScanParamCfg*>(value);
+  if (value != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:stream.ScannerCrtlCfgData.supportParams)
+}
+inline ::stream::ScanParamCfg* ScannerCrtlCfgData::release_supportparams() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  ::stream::ScanParamCfg* released = _impl_.supportparams_;
+  _impl_.supportparams_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
+  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
+  if (GetArenaForAllocation() == nullptr) {
+    delete old;
+  }
+#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return released;
+}
+inline ::stream::ScanParamCfg* ScannerCrtlCfgData::unsafe_arena_release_supportparams() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  // @@protoc_insertion_point(field_release:stream.ScannerCrtlCfgData.supportParams)
+
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  ::stream::ScanParamCfg* temp = _impl_.supportparams_;
+  _impl_.supportparams_ = nullptr;
+  return temp;
+}
+inline ::stream::ScanParamCfg* ScannerCrtlCfgData::_internal_mutable_supportparams() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  _impl_._has_bits_[0] |= 0x00000008u;
+  if (_impl_.supportparams_ == nullptr) {
+    auto* p = CreateMaybeMessage<::stream::ScanParamCfg>(GetArenaForAllocation());
+    _impl_.supportparams_ = reinterpret_cast<::stream::ScanParamCfg*>(p);
+  }
+  return _impl_.supportparams_;
+}
+inline ::stream::ScanParamCfg* ScannerCrtlCfgData::mutable_supportparams() {
+  ::stream::ScanParamCfg* _msg = _internal_mutable_supportparams();
+  // @@protoc_insertion_point(field_mutable:stream.ScannerCrtlCfgData.supportParams)
+  return _msg;
+}
+inline void ScannerCrtlCfgData::set_allocated_supportparams(::stream::ScanParamCfg* value) {
+  ::google::protobuf::Arena* message_arena = GetArenaForAllocation();
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  if (message_arena == nullptr) {
+    delete reinterpret_cast<::stream::ScanParamCfg*>(_impl_.supportparams_);
+  }
+
+  if (value != nullptr) {
+    ::google::protobuf::Arena* submessage_arena =
+        ::google::protobuf::Arena::InternalGetOwningArena(reinterpret_cast<::stream::ScanParamCfg*>(value));
+    if (message_arena != submessage_arena) {
+      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+
+  _impl_.supportparams_ = reinterpret_cast<::stream::ScanParamCfg*>(value);
+  // @@protoc_insertion_point(field_set_allocated:stream.ScannerCrtlCfgData.supportParams)
+}
+
+// .stream.CorrectParamCfg correctParamCfg = 7;
+inline bool ScannerCrtlCfgData::has_correctparamcfg() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.correctparamcfg_ != nullptr);
+  return value;
+}
+inline void ScannerCrtlCfgData::clear_correctparamcfg() {
+  if (_impl_.correctparamcfg_ != nullptr) _impl_.correctparamcfg_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline const ::stream::CorrectParamCfg& ScannerCrtlCfgData::_internal_correctparamcfg() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  const ::stream::CorrectParamCfg* p = _impl_.correctparamcfg_;
+  return p != nullptr ? *p : reinterpret_cast<const ::stream::CorrectParamCfg&>(::stream::_CorrectParamCfg_default_instance_);
+}
+inline const ::stream::CorrectParamCfg& ScannerCrtlCfgData::correctparamcfg() const {
+  // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.correctParamCfg)
+  return _internal_correctparamcfg();
+}
+inline void ScannerCrtlCfgData::unsafe_arena_set_allocated_correctparamcfg(::stream::CorrectParamCfg* value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.correctparamcfg_);
+  }
+  _impl_.correctparamcfg_ = reinterpret_cast<::stream::CorrectParamCfg*>(value);
+  if (value != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:stream.ScannerCrtlCfgData.correctParamCfg)
+}
+inline ::stream::CorrectParamCfg* ScannerCrtlCfgData::release_correctparamcfg() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  ::stream::CorrectParamCfg* released = _impl_.correctparamcfg_;
+  _impl_.correctparamcfg_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
+  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
+  if (GetArenaForAllocation() == nullptr) {
+    delete old;
+  }
+#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return released;
+}
+inline ::stream::CorrectParamCfg* ScannerCrtlCfgData::unsafe_arena_release_correctparamcfg() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  // @@protoc_insertion_point(field_release:stream.ScannerCrtlCfgData.correctParamCfg)
+
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  ::stream::CorrectParamCfg* temp = _impl_.correctparamcfg_;
+  _impl_.correctparamcfg_ = nullptr;
+  return temp;
+}
+inline ::stream::CorrectParamCfg* ScannerCrtlCfgData::_internal_mutable_correctparamcfg() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  _impl_._has_bits_[0] |= 0x00000010u;
+  if (_impl_.correctparamcfg_ == nullptr) {
+    auto* p = CreateMaybeMessage<::stream::CorrectParamCfg>(GetArenaForAllocation());
+    _impl_.correctparamcfg_ = reinterpret_cast<::stream::CorrectParamCfg*>(p);
+  }
+  return _impl_.correctparamcfg_;
+}
+inline ::stream::CorrectParamCfg* ScannerCrtlCfgData::mutable_correctparamcfg() {
+  ::stream::CorrectParamCfg* _msg = _internal_mutable_correctparamcfg();
+  // @@protoc_insertion_point(field_mutable:stream.ScannerCrtlCfgData.correctParamCfg)
+  return _msg;
+}
+inline void ScannerCrtlCfgData::set_allocated_correctparamcfg(::stream::CorrectParamCfg* value) {
+  ::google::protobuf::Arena* message_arena = GetArenaForAllocation();
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  if (message_arena == nullptr) {
+    delete reinterpret_cast<::stream::CorrectParamCfg*>(_impl_.correctparamcfg_);
+  }
+
+  if (value != nullptr) {
+    ::google::protobuf::Arena* submessage_arena =
+        ::google::protobuf::Arena::InternalGetOwningArena(reinterpret_cast<::stream::CorrectParamCfg*>(value));
+    if (message_arena != submessage_arena) {
+      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+
+  _impl_.correctparamcfg_ = reinterpret_cast<::stream::CorrectParamCfg*>(value);
+  // @@protoc_insertion_point(field_set_allocated:stream.ScannerCrtlCfgData.correctParamCfg)
+}
+
+// .stream.ScanTestCfg scanTestCfg = 8;
+inline bool ScannerCrtlCfgData::has_scantestcfg() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.scantestcfg_ != nullptr);
+  return value;
+}
+inline void ScannerCrtlCfgData::clear_scantestcfg() {
+  if (_impl_.scantestcfg_ != nullptr) _impl_.scantestcfg_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline const ::stream::ScanTestCfg& ScannerCrtlCfgData::_internal_scantestcfg() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  const ::stream::ScanTestCfg* p = _impl_.scantestcfg_;
+  return p != nullptr ? *p : reinterpret_cast<const ::stream::ScanTestCfg&>(::stream::_ScanTestCfg_default_instance_);
+}
+inline const ::stream::ScanTestCfg& ScannerCrtlCfgData::scantestcfg() const {
+  // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.scanTestCfg)
+  return _internal_scantestcfg();
+}
+inline void ScannerCrtlCfgData::unsafe_arena_set_allocated_scantestcfg(::stream::ScanTestCfg* value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.scantestcfg_);
+  }
+  _impl_.scantestcfg_ = reinterpret_cast<::stream::ScanTestCfg*>(value);
+  if (value != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000020u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000020u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:stream.ScannerCrtlCfgData.scanTestCfg)
+}
+inline ::stream::ScanTestCfg* ScannerCrtlCfgData::release_scantestcfg() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+
+  _impl_._has_bits_[0] &= ~0x00000020u;
+  ::stream::ScanTestCfg* released = _impl_.scantestcfg_;
+  _impl_.scantestcfg_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
+  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
+  if (GetArenaForAllocation() == nullptr) {
+    delete old;
+  }
+#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return released;
+}
+inline ::stream::ScanTestCfg* ScannerCrtlCfgData::unsafe_arena_release_scantestcfg() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  // @@protoc_insertion_point(field_release:stream.ScannerCrtlCfgData.scanTestCfg)
+
+  _impl_._has_bits_[0] &= ~0x00000020u;
+  ::stream::ScanTestCfg* temp = _impl_.scantestcfg_;
+  _impl_.scantestcfg_ = nullptr;
+  return temp;
+}
+inline ::stream::ScanTestCfg* ScannerCrtlCfgData::_internal_mutable_scantestcfg() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  _impl_._has_bits_[0] |= 0x00000020u;
+  if (_impl_.scantestcfg_ == nullptr) {
+    auto* p = CreateMaybeMessage<::stream::ScanTestCfg>(GetArenaForAllocation());
+    _impl_.scantestcfg_ = reinterpret_cast<::stream::ScanTestCfg*>(p);
+  }
+  return _impl_.scantestcfg_;
+}
+inline ::stream::ScanTestCfg* ScannerCrtlCfgData::mutable_scantestcfg() {
+  ::stream::ScanTestCfg* _msg = _internal_mutable_scantestcfg();
+  // @@protoc_insertion_point(field_mutable:stream.ScannerCrtlCfgData.scanTestCfg)
+  return _msg;
+}
+inline void ScannerCrtlCfgData::set_allocated_scantestcfg(::stream::ScanTestCfg* value) {
+  ::google::protobuf::Arena* message_arena = GetArenaForAllocation();
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  if (message_arena == nullptr) {
+    delete reinterpret_cast<::stream::ScanTestCfg*>(_impl_.scantestcfg_);
+  }
+
+  if (value != nullptr) {
+    ::google::protobuf::Arena* submessage_arena =
+        ::google::protobuf::Arena::InternalGetOwningArena(reinterpret_cast<::stream::ScanTestCfg*>(value));
+    if (message_arena != submessage_arena) {
+      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000020u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000020u;
+  }
+
+  _impl_.scantestcfg_ = reinterpret_cast<::stream::ScanTestCfg*>(value);
+  // @@protoc_insertion_point(field_set_allocated:stream.ScannerCrtlCfgData.scanTestCfg)
+}
+
+// .stream.SkyWritingCfg skyWritingCfg = 9;
+inline bool ScannerCrtlCfgData::has_skywritingcfg() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.skywritingcfg_ != nullptr);
+  return value;
+}
+inline void ScannerCrtlCfgData::clear_skywritingcfg() {
+  if (_impl_.skywritingcfg_ != nullptr) _impl_.skywritingcfg_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000040u;
+}
+inline const ::stream::SkyWritingCfg& ScannerCrtlCfgData::_internal_skywritingcfg() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  const ::stream::SkyWritingCfg* p = _impl_.skywritingcfg_;
+  return p != nullptr ? *p : reinterpret_cast<const ::stream::SkyWritingCfg&>(::stream::_SkyWritingCfg_default_instance_);
+}
+inline const ::stream::SkyWritingCfg& ScannerCrtlCfgData::skywritingcfg() const {
+  // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.skyWritingCfg)
+  return _internal_skywritingcfg();
+}
+inline void ScannerCrtlCfgData::unsafe_arena_set_allocated_skywritingcfg(::stream::SkyWritingCfg* value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.skywritingcfg_);
+  }
+  _impl_.skywritingcfg_ = reinterpret_cast<::stream::SkyWritingCfg*>(value);
+  if (value != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000040u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000040u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:stream.ScannerCrtlCfgData.skyWritingCfg)
+}
+inline ::stream::SkyWritingCfg* ScannerCrtlCfgData::release_skywritingcfg() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+
+  _impl_._has_bits_[0] &= ~0x00000040u;
+  ::stream::SkyWritingCfg* released = _impl_.skywritingcfg_;
+  _impl_.skywritingcfg_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
+  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
+  if (GetArenaForAllocation() == nullptr) {
+    delete old;
+  }
+#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return released;
+}
+inline ::stream::SkyWritingCfg* ScannerCrtlCfgData::unsafe_arena_release_skywritingcfg() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  // @@protoc_insertion_point(field_release:stream.ScannerCrtlCfgData.skyWritingCfg)
+
+  _impl_._has_bits_[0] &= ~0x00000040u;
+  ::stream::SkyWritingCfg* temp = _impl_.skywritingcfg_;
+  _impl_.skywritingcfg_ = nullptr;
+  return temp;
+}
+inline ::stream::SkyWritingCfg* ScannerCrtlCfgData::_internal_mutable_skywritingcfg() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  _impl_._has_bits_[0] |= 0x00000040u;
+  if (_impl_.skywritingcfg_ == nullptr) {
+    auto* p = CreateMaybeMessage<::stream::SkyWritingCfg>(GetArenaForAllocation());
+    _impl_.skywritingcfg_ = reinterpret_cast<::stream::SkyWritingCfg*>(p);
+  }
+  return _impl_.skywritingcfg_;
+}
+inline ::stream::SkyWritingCfg* ScannerCrtlCfgData::mutable_skywritingcfg() {
+  ::stream::SkyWritingCfg* _msg = _internal_mutable_skywritingcfg();
+  // @@protoc_insertion_point(field_mutable:stream.ScannerCrtlCfgData.skyWritingCfg)
+  return _msg;
+}
+inline void ScannerCrtlCfgData::set_allocated_skywritingcfg(::stream::SkyWritingCfg* value) {
+  ::google::protobuf::Arena* message_arena = GetArenaForAllocation();
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  if (message_arena == nullptr) {
+    delete reinterpret_cast<::stream::SkyWritingCfg*>(_impl_.skywritingcfg_);
+  }
+
+  if (value != nullptr) {
+    ::google::protobuf::Arena* submessage_arena =
+        ::google::protobuf::Arena::InternalGetOwningArena(reinterpret_cast<::stream::SkyWritingCfg*>(value));
+    if (message_arena != submessage_arena) {
+      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000040u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000040u;
+  }
+
+  _impl_.skywritingcfg_ = reinterpret_cast<::stream::SkyWritingCfg*>(value);
+  // @@protoc_insertion_point(field_set_allocated:stream.ScannerCrtlCfgData.skyWritingCfg)
+}
+
+// repeated .stream.PowerCompensate powerCompensate = 10;
+inline int ScannerCrtlCfgData::_internal_powercompensate_size() const {
+  return _internal_powercompensate().size();
+}
+inline int ScannerCrtlCfgData::powercompensate_size() const {
+  return _internal_powercompensate_size();
+}
+inline void ScannerCrtlCfgData::clear_powercompensate() {
+  _internal_mutable_powercompensate()->Clear();
+}
+inline ::stream::PowerCompensate* ScannerCrtlCfgData::mutable_powercompensate(int index) {
+  // @@protoc_insertion_point(field_mutable:stream.ScannerCrtlCfgData.powerCompensate)
+  return _internal_mutable_powercompensate()->Mutable(index);
+}
+inline ::google::protobuf::RepeatedPtrField< ::stream::PowerCompensate >*
+ScannerCrtlCfgData::mutable_powercompensate() {
+  // @@protoc_insertion_point(field_mutable_list:stream.ScannerCrtlCfgData.powerCompensate)
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  return _internal_mutable_powercompensate();
+}
+inline const ::stream::PowerCompensate& ScannerCrtlCfgData::powercompensate(int index) const {
+  // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.powerCompensate)
+    return _internal_powercompensate().Get(index);
+}
+inline ::stream::PowerCompensate* ScannerCrtlCfgData::add_powercompensate() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ::stream::PowerCompensate* _add = _internal_mutable_powercompensate()->Add();
+  // @@protoc_insertion_point(field_add:stream.ScannerCrtlCfgData.powerCompensate)
+  return _add;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::stream::PowerCompensate >&
+ScannerCrtlCfgData::powercompensate() const {
+  // @@protoc_insertion_point(field_list:stream.ScannerCrtlCfgData.powerCompensate)
+  return _internal_powercompensate();
+}
+inline const ::google::protobuf::RepeatedPtrField<::stream::PowerCompensate>&
+ScannerCrtlCfgData::_internal_powercompensate() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.powercompensate_;
+}
+inline ::google::protobuf::RepeatedPtrField<::stream::PowerCompensate>*
+ScannerCrtlCfgData::_internal_mutable_powercompensate() {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return &_impl_.powercompensate_;
+}
+
+// repeated .stream.TimePowerCompensate tPowerCompensate = 11;
+inline int ScannerCrtlCfgData::_internal_tpowercompensate_size() const {
+  return _internal_tpowercompensate().size();
+}
+inline int ScannerCrtlCfgData::tpowercompensate_size() const {
+  return _internal_tpowercompensate_size();
+}
+inline void ScannerCrtlCfgData::clear_tpowercompensate() {
+  _internal_mutable_tpowercompensate()->Clear();
+}
+inline ::stream::TimePowerCompensate* ScannerCrtlCfgData::mutable_tpowercompensate(int index) {
+  // @@protoc_insertion_point(field_mutable:stream.ScannerCrtlCfgData.tPowerCompensate)
+  return _internal_mutable_tpowercompensate()->Mutable(index);
+}
+inline ::google::protobuf::RepeatedPtrField< ::stream::TimePowerCompensate >*
+ScannerCrtlCfgData::mutable_tpowercompensate() {
+  // @@protoc_insertion_point(field_mutable_list:stream.ScannerCrtlCfgData.tPowerCompensate)
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  return _internal_mutable_tpowercompensate();
+}
+inline const ::stream::TimePowerCompensate& ScannerCrtlCfgData::tpowercompensate(int index) const {
+  // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.tPowerCompensate)
+    return _internal_tpowercompensate().Get(index);
+}
+inline ::stream::TimePowerCompensate* ScannerCrtlCfgData::add_tpowercompensate() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ::stream::TimePowerCompensate* _add = _internal_mutable_tpowercompensate()->Add();
+  // @@protoc_insertion_point(field_add:stream.ScannerCrtlCfgData.tPowerCompensate)
+  return _add;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::stream::TimePowerCompensate >&
+ScannerCrtlCfgData::tpowercompensate() const {
+  // @@protoc_insertion_point(field_list:stream.ScannerCrtlCfgData.tPowerCompensate)
+  return _internal_tpowercompensate();
+}
+inline const ::google::protobuf::RepeatedPtrField<::stream::TimePowerCompensate>&
+ScannerCrtlCfgData::_internal_tpowercompensate() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.tpowercompensate_;
+}
+inline ::google::protobuf::RepeatedPtrField<::stream::TimePowerCompensate>*
+ScannerCrtlCfgData::_internal_mutable_tpowercompensate() {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return &_impl_.tpowercompensate_;
+}
+
+// int32 controlNo = 12;
+inline void ScannerCrtlCfgData::clear_controlno() {
+  _impl_.controlno_ = 0;
+}
+inline ::int32_t ScannerCrtlCfgData::controlno() const {
+  // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.controlNo)
+  return _internal_controlno();
+}
+inline void ScannerCrtlCfgData::set_controlno(::int32_t value) {
+  _internal_set_controlno(value);
+  // @@protoc_insertion_point(field_set:stream.ScannerCrtlCfgData.controlNo)
+}
+inline ::int32_t ScannerCrtlCfgData::_internal_controlno() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.controlno_;
+}
+inline void ScannerCrtlCfgData::_internal_set_controlno(::int32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.controlno_ = value;
+}
+
+// int32 serialNo = 13;
+inline void ScannerCrtlCfgData::clear_serialno() {
+  _impl_.serialno_ = 0;
+}
+inline ::int32_t ScannerCrtlCfgData::serialno() const {
+  // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.serialNo)
+  return _internal_serialno();
+}
+inline void ScannerCrtlCfgData::set_serialno(::int32_t value) {
+  _internal_set_serialno(value);
+  // @@protoc_insertion_point(field_set:stream.ScannerCrtlCfgData.serialNo)
+}
+inline ::int32_t ScannerCrtlCfgData::_internal_serialno() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.serialno_;
+}
+inline void ScannerCrtlCfgData::_internal_set_serialno(::int32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.serialno_ = value;
+}
+
+// int32 controlType = 14;
+inline void ScannerCrtlCfgData::clear_controltype() {
+  _impl_.controltype_ = 0;
+}
+inline ::int32_t ScannerCrtlCfgData::controltype() const {
+  // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.controlType)
+  return _internal_controltype();
+}
+inline void ScannerCrtlCfgData::set_controltype(::int32_t value) {
+  _internal_set_controltype(value);
+  // @@protoc_insertion_point(field_set:stream.ScannerCrtlCfgData.controlType)
+}
+inline ::int32_t ScannerCrtlCfgData::_internal_controltype() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.controltype_;
+}
+inline void ScannerCrtlCfgData::_internal_set_controltype(::int32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.controltype_ = value;
+}
+
+// bytes cardName = 15;
+inline void ScannerCrtlCfgData::clear_cardname() {
+  _impl_.cardname_.ClearToEmpty();
+}
+inline const std::string& ScannerCrtlCfgData::cardname() const {
+  // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.cardName)
+  return _internal_cardname();
+}
+template <typename Arg_, typename... Args_>
+inline PROTOBUF_ALWAYS_INLINE void ScannerCrtlCfgData::set_cardname(Arg_&& arg,
+                                                     Args_... args) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.cardname_.SetBytes(static_cast<Arg_&&>(arg), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:stream.ScannerCrtlCfgData.cardName)
+}
+inline std::string* ScannerCrtlCfgData::mutable_cardname() {
+  std::string* _s = _internal_mutable_cardname();
+  // @@protoc_insertion_point(field_mutable:stream.ScannerCrtlCfgData.cardName)
+  return _s;
+}
+inline const std::string& ScannerCrtlCfgData::_internal_cardname() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.cardname_.Get();
+}
+inline void ScannerCrtlCfgData::_internal_set_cardname(const std::string& value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.cardname_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ScannerCrtlCfgData::_internal_mutable_cardname() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  return _impl_.cardname_.Mutable( GetArenaForAllocation());
+}
+inline std::string* ScannerCrtlCfgData::release_cardname() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  // @@protoc_insertion_point(field_release:stream.ScannerCrtlCfgData.cardName)
+  return _impl_.cardname_.Release();
+}
+inline void ScannerCrtlCfgData::set_allocated_cardname(std::string* value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  _impl_.cardname_.SetAllocated(value, GetArenaForAllocation());
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        if (_impl_.cardname_.IsDefault()) {
+          _impl_.cardname_.Set("", GetArenaForAllocation());
+        }
+  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:stream.ScannerCrtlCfgData.cardName)
+}
+
+// bytes cardIP = 16;
+inline void ScannerCrtlCfgData::clear_cardip() {
+  _impl_.cardip_.ClearToEmpty();
+}
+inline const std::string& ScannerCrtlCfgData::cardip() const {
+  // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.cardIP)
+  return _internal_cardip();
+}
+template <typename Arg_, typename... Args_>
+inline PROTOBUF_ALWAYS_INLINE void ScannerCrtlCfgData::set_cardip(Arg_&& arg,
+                                                     Args_... args) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.cardip_.SetBytes(static_cast<Arg_&&>(arg), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:stream.ScannerCrtlCfgData.cardIP)
+}
+inline std::string* ScannerCrtlCfgData::mutable_cardip() {
+  std::string* _s = _internal_mutable_cardip();
+  // @@protoc_insertion_point(field_mutable:stream.ScannerCrtlCfgData.cardIP)
+  return _s;
+}
+inline const std::string& ScannerCrtlCfgData::_internal_cardip() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.cardip_.Get();
+}
+inline void ScannerCrtlCfgData::_internal_set_cardip(const std::string& value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.cardip_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ScannerCrtlCfgData::_internal_mutable_cardip() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  return _impl_.cardip_.Mutable( GetArenaForAllocation());
+}
+inline std::string* ScannerCrtlCfgData::release_cardip() {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  // @@protoc_insertion_point(field_release:stream.ScannerCrtlCfgData.cardIP)
+  return _impl_.cardip_.Release();
+}
+inline void ScannerCrtlCfgData::set_allocated_cardip(std::string* value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  _impl_.cardip_.SetAllocated(value, GetArenaForAllocation());
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        if (_impl_.cardip_.IsDefault()) {
+          _impl_.cardip_.Set("", GetArenaForAllocation());
+        }
+  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:stream.ScannerCrtlCfgData.cardIP)
+}
+
+// bool isEnable = 17;
+inline void ScannerCrtlCfgData::clear_isenable() {
+  _impl_.isenable_ = false;
+}
+inline bool ScannerCrtlCfgData::isenable() const {
+  // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.isEnable)
+  return _internal_isenable();
+}
+inline void ScannerCrtlCfgData::set_isenable(bool value) {
+  _internal_set_isenable(value);
+  // @@protoc_insertion_point(field_set:stream.ScannerCrtlCfgData.isEnable)
+}
+inline bool ScannerCrtlCfgData::_internal_isenable() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.isenable_;
+}
+inline void ScannerCrtlCfgData::_internal_set_isenable(bool value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.isenable_ = value;
+}
+
+// bool hadAssign = 18;
+inline void ScannerCrtlCfgData::clear_hadassign() {
+  _impl_.hadassign_ = false;
+}
+inline bool ScannerCrtlCfgData::hadassign() const {
+  // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.hadAssign)
+  return _internal_hadassign();
+}
+inline void ScannerCrtlCfgData::set_hadassign(bool value) {
+  _internal_set_hadassign(value);
+  // @@protoc_insertion_point(field_set:stream.ScannerCrtlCfgData.hadAssign)
+}
+inline bool ScannerCrtlCfgData::_internal_hadassign() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.hadassign_;
+}
+inline void ScannerCrtlCfgData::_internal_set_hadassign(bool value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.hadassign_ = value;
+}
+
+// bool hadMatch = 19;
+inline void ScannerCrtlCfgData::clear_hadmatch() {
+  _impl_.hadmatch_ = false;
+}
+inline bool ScannerCrtlCfgData::hadmatch() const {
+  // @@protoc_insertion_point(field_get:stream.ScannerCrtlCfgData.hadMatch)
+  return _internal_hadmatch();
+}
+inline void ScannerCrtlCfgData::set_hadmatch(bool value) {
+  _internal_set_hadmatch(value);
+  // @@protoc_insertion_point(field_set:stream.ScannerCrtlCfgData.hadMatch)
+}
+inline bool ScannerCrtlCfgData::_internal_hadmatch() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.hadmatch_;
+}
+inline void ScannerCrtlCfgData::_internal_set_hadmatch(bool value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.hadmatch_ = value;
+}
+
+// -------------------------------------------------------------------
+
+// FixPointData
+
+// int32 id = 1;
+inline void FixPointData::clear_id() {
+  _impl_.id_ = 0;
+}
+inline ::int32_t FixPointData::id() const {
+  // @@protoc_insertion_point(field_get:stream.FixPointData.id)
+  return _internal_id();
+}
+inline void FixPointData::set_id(::int32_t value) {
+  _internal_set_id(value);
+  // @@protoc_insertion_point(field_set:stream.FixPointData.id)
+}
+inline ::int32_t FixPointData::_internal_id() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.id_;
+}
+inline void FixPointData::_internal_set_id(::int32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.id_ = value;
+}
+
+// int32 cno = 2;
+inline void FixPointData::clear_cno() {
+  _impl_.cno_ = 0;
+}
+inline ::int32_t FixPointData::cno() const {
+  // @@protoc_insertion_point(field_get:stream.FixPointData.cno)
+  return _internal_cno();
+}
+inline void FixPointData::set_cno(::int32_t value) {
+  _internal_set_cno(value);
+  // @@protoc_insertion_point(field_set:stream.FixPointData.cno)
+}
+inline ::int32_t FixPointData::_internal_cno() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.cno_;
+}
+inline void FixPointData::_internal_set_cno(::int32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.cno_ = value;
+}
+
+// float pointX = 3;
+inline void FixPointData::clear_pointx() {
+  _impl_.pointx_ = 0;
+}
+inline float FixPointData::pointx() const {
+  // @@protoc_insertion_point(field_get:stream.FixPointData.pointX)
+  return _internal_pointx();
+}
+inline void FixPointData::set_pointx(float value) {
+  _internal_set_pointx(value);
+  // @@protoc_insertion_point(field_set:stream.FixPointData.pointX)
+}
+inline float FixPointData::_internal_pointx() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.pointx_;
+}
+inline void FixPointData::_internal_set_pointx(float value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.pointx_ = value;
+}
+
+// float pointY = 4;
+inline void FixPointData::clear_pointy() {
+  _impl_.pointy_ = 0;
+}
+inline float FixPointData::pointy() const {
+  // @@protoc_insertion_point(field_get:stream.FixPointData.pointY)
+  return _internal_pointy();
+}
+inline void FixPointData::set_pointy(float value) {
+  _internal_set_pointy(value);
+  // @@protoc_insertion_point(field_set:stream.FixPointData.pointY)
+}
+inline float FixPointData::_internal_pointy() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.pointy_;
+}
+inline void FixPointData::_internal_set_pointy(float value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.pointy_ = value;
+}
+
+// uint32 duration = 5;
+inline void FixPointData::clear_duration() {
+  _impl_.duration_ = 0u;
+}
+inline ::uint32_t FixPointData::duration() const {
+  // @@protoc_insertion_point(field_get:stream.FixPointData.duration)
+  return _internal_duration();
+}
+inline void FixPointData::set_duration(::uint32_t value) {
+  _internal_set_duration(value);
+  // @@protoc_insertion_point(field_set:stream.FixPointData.duration)
+}
+inline ::uint32_t FixPointData::_internal_duration() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.duration_;
+}
+inline void FixPointData::_internal_set_duration(::uint32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.duration_ = value;
+}
+
+// -------------------------------------------------------------------
+
+// ScanParamCfg
+
+// int32 edgeLevel = 1;
+inline void ScanParamCfg::clear_edgelevel() {
+  _impl_.edgelevel_ = 0;
+}
+inline ::int32_t ScanParamCfg::edgelevel() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.edgeLevel)
+  return _internal_edgelevel();
+}
+inline void ScanParamCfg::set_edgelevel(::int32_t value) {
+  _internal_set_edgelevel(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.edgeLevel)
+}
+inline ::int32_t ScanParamCfg::_internal_edgelevel() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.edgelevel_;
+}
+inline void ScanParamCfg::_internal_set_edgelevel(::int32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.edgelevel_ = value;
+}
+
+// int32 edgeLevelMin = 2;
+inline void ScanParamCfg::clear_edgelevelmin() {
+  _impl_.edgelevelmin_ = 0;
+}
+inline ::int32_t ScanParamCfg::edgelevelmin() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.edgeLevelMin)
+  return _internal_edgelevelmin();
+}
+inline void ScanParamCfg::set_edgelevelmin(::int32_t value) {
+  _internal_set_edgelevelmin(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.edgeLevelMin)
+}
+inline ::int32_t ScanParamCfg::_internal_edgelevelmin() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.edgelevelmin_;
+}
+inline void ScanParamCfg::_internal_set_edgelevelmin(::int32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.edgelevelmin_ = value;
+}
+
+// int32 edgeLevelMax = 3;
+inline void ScanParamCfg::clear_edgelevelmax() {
+  _impl_.edgelevelmax_ = 0;
+}
+inline ::int32_t ScanParamCfg::edgelevelmax() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.edgeLevelMax)
+  return _internal_edgelevelmax();
+}
+inline void ScanParamCfg::set_edgelevelmax(::int32_t value) {
+  _internal_set_edgelevelmax(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.edgeLevelMax)
+}
+inline ::int32_t ScanParamCfg::_internal_edgelevelmax() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.edgelevelmax_;
+}
+inline void ScanParamCfg::_internal_set_edgelevelmax(::int32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.edgelevelmax_ = value;
+}
+
+// uint32 jumpDelay = 4;
+inline void ScanParamCfg::clear_jumpdelay() {
+  _impl_.jumpdelay_ = 0u;
+}
+inline ::uint32_t ScanParamCfg::jumpdelay() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.jumpDelay)
+  return _internal_jumpdelay();
+}
+inline void ScanParamCfg::set_jumpdelay(::uint32_t value) {
+  _internal_set_jumpdelay(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.jumpDelay)
+}
+inline ::uint32_t ScanParamCfg::_internal_jumpdelay() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.jumpdelay_;
+}
+inline void ScanParamCfg::_internal_set_jumpdelay(::uint32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.jumpdelay_ = value;
+}
+
+// uint32 jumpDelayMin = 5;
+inline void ScanParamCfg::clear_jumpdelaymin() {
+  _impl_.jumpdelaymin_ = 0u;
+}
+inline ::uint32_t ScanParamCfg::jumpdelaymin() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.jumpDelayMin)
+  return _internal_jumpdelaymin();
+}
+inline void ScanParamCfg::set_jumpdelaymin(::uint32_t value) {
+  _internal_set_jumpdelaymin(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.jumpDelayMin)
+}
+inline ::uint32_t ScanParamCfg::_internal_jumpdelaymin() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.jumpdelaymin_;
+}
+inline void ScanParamCfg::_internal_set_jumpdelaymin(::uint32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.jumpdelaymin_ = value;
+}
+
+// uint32 jumpDelayMax = 6;
+inline void ScanParamCfg::clear_jumpdelaymax() {
+  _impl_.jumpdelaymax_ = 0u;
+}
+inline ::uint32_t ScanParamCfg::jumpdelaymax() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.jumpDelayMax)
+  return _internal_jumpdelaymax();
+}
+inline void ScanParamCfg::set_jumpdelaymax(::uint32_t value) {
+  _internal_set_jumpdelaymax(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.jumpDelayMax)
+}
+inline ::uint32_t ScanParamCfg::_internal_jumpdelaymax() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.jumpdelaymax_;
+}
+inline void ScanParamCfg::_internal_set_jumpdelaymax(::uint32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.jumpdelaymax_ = value;
+}
+
+// uint32 scanDelay = 7;
+inline void ScanParamCfg::clear_scandelay() {
+  _impl_.scandelay_ = 0u;
+}
+inline ::uint32_t ScanParamCfg::scandelay() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.scanDelay)
+  return _internal_scandelay();
+}
+inline void ScanParamCfg::set_scandelay(::uint32_t value) {
+  _internal_set_scandelay(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.scanDelay)
+}
+inline ::uint32_t ScanParamCfg::_internal_scandelay() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.scandelay_;
+}
+inline void ScanParamCfg::_internal_set_scandelay(::uint32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.scandelay_ = value;
+}
+
+// uint32 scanDelayMin = 8;
+inline void ScanParamCfg::clear_scandelaymin() {
+  _impl_.scandelaymin_ = 0u;
+}
+inline ::uint32_t ScanParamCfg::scandelaymin() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.scanDelayMin)
+  return _internal_scandelaymin();
+}
+inline void ScanParamCfg::set_scandelaymin(::uint32_t value) {
+  _internal_set_scandelaymin(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.scanDelayMin)
+}
+inline ::uint32_t ScanParamCfg::_internal_scandelaymin() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.scandelaymin_;
+}
+inline void ScanParamCfg::_internal_set_scandelaymin(::uint32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.scandelaymin_ = value;
+}
+
+// uint32 scanDelayMax = 9;
+inline void ScanParamCfg::clear_scandelaymax() {
+  _impl_.scandelaymax_ = 0u;
+}
+inline ::uint32_t ScanParamCfg::scandelaymax() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.scanDelayMax)
+  return _internal_scandelaymax();
+}
+inline void ScanParamCfg::set_scandelaymax(::uint32_t value) {
+  _internal_set_scandelaymax(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.scanDelayMax)
+}
+inline ::uint32_t ScanParamCfg::_internal_scandelaymax() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.scandelaymax_;
+}
+inline void ScanParamCfg::_internal_set_scandelaymax(::uint32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.scandelaymax_ = value;
+}
+
+// uint32 polygonDelay = 10;
+inline void ScanParamCfg::clear_polygondelay() {
+  _impl_.polygondelay_ = 0u;
+}
+inline ::uint32_t ScanParamCfg::polygondelay() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.polygonDelay)
+  return _internal_polygondelay();
+}
+inline void ScanParamCfg::set_polygondelay(::uint32_t value) {
+  _internal_set_polygondelay(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.polygonDelay)
+}
+inline ::uint32_t ScanParamCfg::_internal_polygondelay() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.polygondelay_;
+}
+inline void ScanParamCfg::_internal_set_polygondelay(::uint32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.polygondelay_ = value;
+}
+
+// uint32 polygonDelayMin = 11;
+inline void ScanParamCfg::clear_polygondelaymin() {
+  _impl_.polygondelaymin_ = 0u;
+}
+inline ::uint32_t ScanParamCfg::polygondelaymin() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.polygonDelayMin)
+  return _internal_polygondelaymin();
+}
+inline void ScanParamCfg::set_polygondelaymin(::uint32_t value) {
+  _internal_set_polygondelaymin(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.polygonDelayMin)
+}
+inline ::uint32_t ScanParamCfg::_internal_polygondelaymin() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.polygondelaymin_;
+}
+inline void ScanParamCfg::_internal_set_polygondelaymin(::uint32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.polygondelaymin_ = value;
+}
+
+// uint32 polygonDelayMax = 12;
+inline void ScanParamCfg::clear_polygondelaymax() {
+  _impl_.polygondelaymax_ = 0u;
+}
+inline ::uint32_t ScanParamCfg::polygondelaymax() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.polygonDelayMax)
+  return _internal_polygondelaymax();
+}
+inline void ScanParamCfg::set_polygondelaymax(::uint32_t value) {
+  _internal_set_polygondelaymax(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.polygonDelayMax)
+}
+inline ::uint32_t ScanParamCfg::_internal_polygondelaymax() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.polygondelaymax_;
+}
+inline void ScanParamCfg::_internal_set_polygondelaymax(::uint32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.polygondelaymax_ = value;
+}
+
+// int64 laseroffDelay = 13;
+inline void ScanParamCfg::clear_laseroffdelay() {
+  _impl_.laseroffdelay_ = ::int64_t{0};
+}
+inline ::int64_t ScanParamCfg::laseroffdelay() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.laseroffDelay)
+  return _internal_laseroffdelay();
+}
+inline void ScanParamCfg::set_laseroffdelay(::int64_t value) {
+  _internal_set_laseroffdelay(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.laseroffDelay)
+}
+inline ::int64_t ScanParamCfg::_internal_laseroffdelay() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.laseroffdelay_;
+}
+inline void ScanParamCfg::_internal_set_laseroffdelay(::int64_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.laseroffdelay_ = value;
+}
+
+// int64 laseroffDelayMin = 14;
+inline void ScanParamCfg::clear_laseroffdelaymin() {
+  _impl_.laseroffdelaymin_ = ::int64_t{0};
+}
+inline ::int64_t ScanParamCfg::laseroffdelaymin() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.laseroffDelayMin)
+  return _internal_laseroffdelaymin();
+}
+inline void ScanParamCfg::set_laseroffdelaymin(::int64_t value) {
+  _internal_set_laseroffdelaymin(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.laseroffDelayMin)
+}
+inline ::int64_t ScanParamCfg::_internal_laseroffdelaymin() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.laseroffdelaymin_;
+}
+inline void ScanParamCfg::_internal_set_laseroffdelaymin(::int64_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.laseroffdelaymin_ = value;
+}
+
+// int64 laseroffDelayMax = 15;
+inline void ScanParamCfg::clear_laseroffdelaymax() {
+  _impl_.laseroffdelaymax_ = ::int64_t{0};
+}
+inline ::int64_t ScanParamCfg::laseroffdelaymax() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.laseroffDelayMax)
+  return _internal_laseroffdelaymax();
+}
+inline void ScanParamCfg::set_laseroffdelaymax(::int64_t value) {
+  _internal_set_laseroffdelaymax(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.laseroffDelayMax)
+}
+inline ::int64_t ScanParamCfg::_internal_laseroffdelaymax() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.laseroffdelaymax_;
+}
+inline void ScanParamCfg::_internal_set_laseroffdelaymax(::int64_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.laseroffdelaymax_ = value;
+}
+
+// int64 laseronDelay = 16;
+inline void ScanParamCfg::clear_laserondelay() {
+  _impl_.laserondelay_ = ::int64_t{0};
+}
+inline ::int64_t ScanParamCfg::laserondelay() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.laseronDelay)
+  return _internal_laserondelay();
+}
+inline void ScanParamCfg::set_laserondelay(::int64_t value) {
+  _internal_set_laserondelay(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.laseronDelay)
+}
+inline ::int64_t ScanParamCfg::_internal_laserondelay() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.laserondelay_;
+}
+inline void ScanParamCfg::_internal_set_laserondelay(::int64_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.laserondelay_ = value;
+}
+
+// int64 laseronDelayMin = 17;
+inline void ScanParamCfg::clear_laserondelaymin() {
+  _impl_.laserondelaymin_ = ::int64_t{0};
+}
+inline ::int64_t ScanParamCfg::laserondelaymin() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.laseronDelayMin)
+  return _internal_laserondelaymin();
+}
+inline void ScanParamCfg::set_laserondelaymin(::int64_t value) {
+  _internal_set_laserondelaymin(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.laseronDelayMin)
+}
+inline ::int64_t ScanParamCfg::_internal_laserondelaymin() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.laserondelaymin_;
+}
+inline void ScanParamCfg::_internal_set_laserondelaymin(::int64_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.laserondelaymin_ = value;
+}
+
+// int64 laseronDelayMax = 18;
+inline void ScanParamCfg::clear_laserondelaymax() {
+  _impl_.laserondelaymax_ = ::int64_t{0};
+}
+inline ::int64_t ScanParamCfg::laserondelaymax() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.laseronDelayMax)
+  return _internal_laserondelaymax();
+}
+inline void ScanParamCfg::set_laserondelaymax(::int64_t value) {
+  _internal_set_laserondelaymax(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.laseronDelayMax)
+}
+inline ::int64_t ScanParamCfg::_internal_laserondelaymax() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.laserondelaymax_;
+}
+inline void ScanParamCfg::_internal_set_laserondelaymax(::int64_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.laserondelaymax_ = value;
+}
+
+// uint32 minJumpDelay = 19;
+inline void ScanParamCfg::clear_minjumpdelay() {
+  _impl_.minjumpdelay_ = 0u;
+}
+inline ::uint32_t ScanParamCfg::minjumpdelay() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.minJumpDelay)
+  return _internal_minjumpdelay();
+}
+inline void ScanParamCfg::set_minjumpdelay(::uint32_t value) {
+  _internal_set_minjumpdelay(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.minJumpDelay)
+}
+inline ::uint32_t ScanParamCfg::_internal_minjumpdelay() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.minjumpdelay_;
+}
+inline void ScanParamCfg::_internal_set_minjumpdelay(::uint32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.minjumpdelay_ = value;
+}
+
+// uint32 minJumpDelayMin = 20;
+inline void ScanParamCfg::clear_minjumpdelaymin() {
+  _impl_.minjumpdelaymin_ = 0u;
+}
+inline ::uint32_t ScanParamCfg::minjumpdelaymin() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.minJumpDelayMin)
+  return _internal_minjumpdelaymin();
+}
+inline void ScanParamCfg::set_minjumpdelaymin(::uint32_t value) {
+  _internal_set_minjumpdelaymin(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.minJumpDelayMin)
+}
+inline ::uint32_t ScanParamCfg::_internal_minjumpdelaymin() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.minjumpdelaymin_;
+}
+inline void ScanParamCfg::_internal_set_minjumpdelaymin(::uint32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.minjumpdelaymin_ = value;
+}
+
+// uint32 minJumpDelayMax = 21;
+inline void ScanParamCfg::clear_minjumpdelaymax() {
+  _impl_.minjumpdelaymax_ = 0u;
+}
+inline ::uint32_t ScanParamCfg::minjumpdelaymax() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.minJumpDelayMax)
+  return _internal_minjumpdelaymax();
+}
+inline void ScanParamCfg::set_minjumpdelaymax(::uint32_t value) {
+  _internal_set_minjumpdelaymax(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.minJumpDelayMax)
+}
+inline ::uint32_t ScanParamCfg::_internal_minjumpdelaymax() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.minjumpdelaymax_;
+}
+inline void ScanParamCfg::_internal_set_minjumpdelaymax(::uint32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.minjumpdelaymax_ = value;
+}
+
+// uint32 jumpLengthLimit = 22;
+inline void ScanParamCfg::clear_jumplengthlimit() {
+  _impl_.jumplengthlimit_ = 0u;
+}
+inline ::uint32_t ScanParamCfg::jumplengthlimit() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.jumpLengthLimit)
+  return _internal_jumplengthlimit();
+}
+inline void ScanParamCfg::set_jumplengthlimit(::uint32_t value) {
+  _internal_set_jumplengthlimit(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.jumpLengthLimit)
+}
+inline ::uint32_t ScanParamCfg::_internal_jumplengthlimit() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.jumplengthlimit_;
+}
+inline void ScanParamCfg::_internal_set_jumplengthlimit(::uint32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.jumplengthlimit_ = value;
+}
+
+// uint32 jumpLengthLimitMin = 23;
+inline void ScanParamCfg::clear_jumplengthlimitmin() {
+  _impl_.jumplengthlimitmin_ = 0u;
+}
+inline ::uint32_t ScanParamCfg::jumplengthlimitmin() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.jumpLengthLimitMin)
+  return _internal_jumplengthlimitmin();
+}
+inline void ScanParamCfg::set_jumplengthlimitmin(::uint32_t value) {
+  _internal_set_jumplengthlimitmin(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.jumpLengthLimitMin)
+}
+inline ::uint32_t ScanParamCfg::_internal_jumplengthlimitmin() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.jumplengthlimitmin_;
+}
+inline void ScanParamCfg::_internal_set_jumplengthlimitmin(::uint32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.jumplengthlimitmin_ = value;
+}
+
+// uint32 jumpLengthLimitMax = 24;
+inline void ScanParamCfg::clear_jumplengthlimitmax() {
+  _impl_.jumplengthlimitmax_ = 0u;
+}
+inline ::uint32_t ScanParamCfg::jumplengthlimitmax() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.jumpLengthLimitMax)
+  return _internal_jumplengthlimitmax();
+}
+inline void ScanParamCfg::set_jumplengthlimitmax(::uint32_t value) {
+  _internal_set_jumplengthlimitmax(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.jumpLengthLimitMax)
+}
+inline ::uint32_t ScanParamCfg::_internal_jumplengthlimitmax() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.jumplengthlimitmax_;
+}
+inline void ScanParamCfg::_internal_set_jumplengthlimitmax(::uint32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.jumplengthlimitmax_ = value;
+}
+
+// double jumpSpeed = 25;
+inline void ScanParamCfg::clear_jumpspeed() {
+  _impl_.jumpspeed_ = 0;
+}
+inline double ScanParamCfg::jumpspeed() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.jumpSpeed)
+  return _internal_jumpspeed();
+}
+inline void ScanParamCfg::set_jumpspeed(double value) {
+  _internal_set_jumpspeed(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.jumpSpeed)
+}
+inline double ScanParamCfg::_internal_jumpspeed() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.jumpspeed_;
+}
+inline void ScanParamCfg::_internal_set_jumpspeed(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.jumpspeed_ = value;
+}
+
+// double jumpSpeedMin = 26;
+inline void ScanParamCfg::clear_jumpspeedmin() {
+  _impl_.jumpspeedmin_ = 0;
+}
+inline double ScanParamCfg::jumpspeedmin() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.jumpSpeedMin)
+  return _internal_jumpspeedmin();
+}
+inline void ScanParamCfg::set_jumpspeedmin(double value) {
+  _internal_set_jumpspeedmin(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.jumpSpeedMin)
+}
+inline double ScanParamCfg::_internal_jumpspeedmin() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.jumpspeedmin_;
+}
+inline void ScanParamCfg::_internal_set_jumpspeedmin(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.jumpspeedmin_ = value;
+}
+
+// double jumpSpeedMax = 27;
+inline void ScanParamCfg::clear_jumpspeedmax() {
+  _impl_.jumpspeedmax_ = 0;
+}
+inline double ScanParamCfg::jumpspeedmax() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.jumpSpeedMax)
+  return _internal_jumpspeedmax();
+}
+inline void ScanParamCfg::set_jumpspeedmax(double value) {
+  _internal_set_jumpspeedmax(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.jumpSpeedMax)
+}
+inline double ScanParamCfg::_internal_jumpspeedmax() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.jumpspeedmax_;
+}
+inline void ScanParamCfg::_internal_set_jumpspeedmax(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.jumpspeedmax_ = value;
+}
+
+// double markSpeed = 28;
+inline void ScanParamCfg::clear_markspeed() {
+  _impl_.markspeed_ = 0;
+}
+inline double ScanParamCfg::markspeed() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.markSpeed)
+  return _internal_markspeed();
+}
+inline void ScanParamCfg::set_markspeed(double value) {
+  _internal_set_markspeed(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.markSpeed)
+}
+inline double ScanParamCfg::_internal_markspeed() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.markspeed_;
+}
+inline void ScanParamCfg::_internal_set_markspeed(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.markspeed_ = value;
+}
+
+// double markSpeedMin = 29;
+inline void ScanParamCfg::clear_markspeedmin() {
+  _impl_.markspeedmin_ = 0;
+}
+inline double ScanParamCfg::markspeedmin() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.markSpeedMin)
+  return _internal_markspeedmin();
+}
+inline void ScanParamCfg::set_markspeedmin(double value) {
+  _internal_set_markspeedmin(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.markSpeedMin)
+}
+inline double ScanParamCfg::_internal_markspeedmin() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.markspeedmin_;
+}
+inline void ScanParamCfg::_internal_set_markspeedmin(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.markspeedmin_ = value;
+}
+
+// double markSpeedMax = 30;
+inline void ScanParamCfg::clear_markspeedmax() {
+  _impl_.markspeedmax_ = 0;
+}
+inline double ScanParamCfg::markspeedmax() const {
+  // @@protoc_insertion_point(field_get:stream.ScanParamCfg.markSpeedMax)
+  return _internal_markspeedmax();
+}
+inline void ScanParamCfg::set_markspeedmax(double value) {
+  _internal_set_markspeedmax(value);
+  // @@protoc_insertion_point(field_set:stream.ScanParamCfg.markSpeedMax)
+}
+inline double ScanParamCfg::_internal_markspeedmax() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.markspeedmax_;
+}
+inline void ScanParamCfg::_internal_set_markspeedmax(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.markspeedmax_ = value;
+}
+
+// -------------------------------------------------------------------
+
+// CorrectParamCfg
+
+// double xmeasureMin = 1;
+inline void CorrectParamCfg::clear_xmeasuremin() {
+  _impl_.xmeasuremin_ = 0;
+}
+inline double CorrectParamCfg::xmeasuremin() const {
+  // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.xmeasureMin)
+  return _internal_xmeasuremin();
+}
+inline void CorrectParamCfg::set_xmeasuremin(double value) {
+  _internal_set_xmeasuremin(value);
+  // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.xmeasureMin)
+}
+inline double CorrectParamCfg::_internal_xmeasuremin() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.xmeasuremin_;
+}
+inline void CorrectParamCfg::_internal_set_xmeasuremin(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.xmeasuremin_ = value;
+}
+
+// double xmeasureMax = 2;
+inline void CorrectParamCfg::clear_xmeasuremax() {
+  _impl_.xmeasuremax_ = 0;
+}
+inline double CorrectParamCfg::xmeasuremax() const {
+  // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.xmeasureMax)
+  return _internal_xmeasuremax();
+}
+inline void CorrectParamCfg::set_xmeasuremax(double value) {
+  _internal_set_xmeasuremax(value);
+  // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.xmeasureMax)
+}
+inline double CorrectParamCfg::_internal_xmeasuremax() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.xmeasuremax_;
+}
+inline void CorrectParamCfg::_internal_set_xmeasuremax(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.xmeasuremax_ = value;
+}
+
+// double ymeasureMin = 3;
+inline void CorrectParamCfg::clear_ymeasuremin() {
+  _impl_.ymeasuremin_ = 0;
+}
+inline double CorrectParamCfg::ymeasuremin() const {
+  // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.ymeasureMin)
+  return _internal_ymeasuremin();
+}
+inline void CorrectParamCfg::set_ymeasuremin(double value) {
+  _internal_set_ymeasuremin(value);
+  // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.ymeasureMin)
+}
+inline double CorrectParamCfg::_internal_ymeasuremin() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.ymeasuremin_;
+}
+inline void CorrectParamCfg::_internal_set_ymeasuremin(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.ymeasuremin_ = value;
+}
+
+// double ymeasureMax = 4;
+inline void CorrectParamCfg::clear_ymeasuremax() {
+  _impl_.ymeasuremax_ = 0;
+}
+inline double CorrectParamCfg::ymeasuremax() const {
+  // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.ymeasureMax)
+  return _internal_ymeasuremax();
+}
+inline void CorrectParamCfg::set_ymeasuremax(double value) {
+  _internal_set_ymeasuremax(value);
+  // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.ymeasureMax)
+}
+inline double CorrectParamCfg::_internal_ymeasuremax() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.ymeasuremax_;
+}
+inline void CorrectParamCfg::_internal_set_ymeasuremax(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.ymeasuremax_ = value;
+}
+
+// double xposfix = 5;
+inline void CorrectParamCfg::clear_xposfix() {
+  _impl_.xposfix_ = 0;
+}
+inline double CorrectParamCfg::xposfix() const {
+  // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.xposfix)
+  return _internal_xposfix();
+}
+inline void CorrectParamCfg::set_xposfix(double value) {
+  _internal_set_xposfix(value);
+  // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.xposfix)
+}
+inline double CorrectParamCfg::_internal_xposfix() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.xposfix_;
+}
+inline void CorrectParamCfg::_internal_set_xposfix(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.xposfix_ = value;
+}
+
+// double yposfix = 6;
+inline void CorrectParamCfg::clear_yposfix() {
+  _impl_.yposfix_ = 0;
+}
+inline double CorrectParamCfg::yposfix() const {
+  // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.yposfix)
+  return _internal_yposfix();
+}
+inline void CorrectParamCfg::set_yposfix(double value) {
+  _internal_set_yposfix(value);
+  // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.yposfix)
+}
+inline double CorrectParamCfg::_internal_yposfix() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.yposfix_;
+}
+inline void CorrectParamCfg::_internal_set_yposfix(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.yposfix_ = value;
+}
+
+// double scanAngle = 7;
+inline void CorrectParamCfg::clear_scanangle() {
+  _impl_.scanangle_ = 0;
+}
+inline double CorrectParamCfg::scanangle() const {
+  // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.scanAngle)
+  return _internal_scanangle();
+}
+inline void CorrectParamCfg::set_scanangle(double value) {
+  _internal_set_scanangle(value);
+  // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.scanAngle)
+}
+inline double CorrectParamCfg::_internal_scanangle() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.scanangle_;
+}
+inline void CorrectParamCfg::_internal_set_scanangle(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.scanangle_ = value;
+}
+
+// double scanAngleMin = 8;
+inline void CorrectParamCfg::clear_scananglemin() {
+  _impl_.scananglemin_ = 0;
+}
+inline double CorrectParamCfg::scananglemin() const {
+  // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.scanAngleMin)
+  return _internal_scananglemin();
+}
+inline void CorrectParamCfg::set_scananglemin(double value) {
+  _internal_set_scananglemin(value);
+  // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.scanAngleMin)
+}
+inline double CorrectParamCfg::_internal_scananglemin() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.scananglemin_;
+}
+inline void CorrectParamCfg::_internal_set_scananglemin(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.scananglemin_ = value;
+}
+
+// double scanAngleMax = 9;
+inline void CorrectParamCfg::clear_scananglemax() {
+  _impl_.scananglemax_ = 0;
+}
+inline double CorrectParamCfg::scananglemax() const {
+  // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.scanAngleMax)
+  return _internal_scananglemax();
+}
+inline void CorrectParamCfg::set_scananglemax(double value) {
+  _internal_set_scananglemax(value);
+  // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.scanAngleMax)
+}
+inline double CorrectParamCfg::_internal_scananglemax() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.scananglemax_;
+}
+inline void CorrectParamCfg::_internal_set_scananglemax(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.scananglemax_ = value;
+}
+
+// double fixAngle = 10;
+inline void CorrectParamCfg::clear_fixangle() {
+  _impl_.fixangle_ = 0;
+}
+inline double CorrectParamCfg::fixangle() const {
+  // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.fixAngle)
+  return _internal_fixangle();
+}
+inline void CorrectParamCfg::set_fixangle(double value) {
+  _internal_set_fixangle(value);
+  // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.fixAngle)
+}
+inline double CorrectParamCfg::_internal_fixangle() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.fixangle_;
+}
+inline void CorrectParamCfg::_internal_set_fixangle(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.fixangle_ = value;
+}
+
+// double fixAngleMin = 11;
+inline void CorrectParamCfg::clear_fixanglemin() {
+  _impl_.fixanglemin_ = 0;
+}
+inline double CorrectParamCfg::fixanglemin() const {
+  // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.fixAngleMin)
+  return _internal_fixanglemin();
+}
+inline void CorrectParamCfg::set_fixanglemin(double value) {
+  _internal_set_fixanglemin(value);
+  // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.fixAngleMin)
+}
+inline double CorrectParamCfg::_internal_fixanglemin() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.fixanglemin_;
+}
+inline void CorrectParamCfg::_internal_set_fixanglemin(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.fixanglemin_ = value;
+}
+
+// double fixAngleMax = 12;
+inline void CorrectParamCfg::clear_fixanglemax() {
+  _impl_.fixanglemax_ = 0;
+}
+inline double CorrectParamCfg::fixanglemax() const {
+  // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.fixAngleMax)
+  return _internal_fixanglemax();
+}
+inline void CorrectParamCfg::set_fixanglemax(double value) {
+  _internal_set_fixanglemax(value);
+  // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.fixAngleMax)
+}
+inline double CorrectParamCfg::_internal_fixanglemax() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.fixanglemax_;
+}
+inline void CorrectParamCfg::_internal_set_fixanglemax(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.fixanglemax_ = value;
+}
+
+// double xcorrect = 13;
+inline void CorrectParamCfg::clear_xcorrect() {
+  _impl_.xcorrect_ = 0;
+}
+inline double CorrectParamCfg::xcorrect() const {
+  // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.xcorrect)
+  return _internal_xcorrect();
+}
+inline void CorrectParamCfg::set_xcorrect(double value) {
+  _internal_set_xcorrect(value);
+  // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.xcorrect)
+}
+inline double CorrectParamCfg::_internal_xcorrect() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.xcorrect_;
+}
+inline void CorrectParamCfg::_internal_set_xcorrect(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.xcorrect_ = value;
+}
+
+// double ycorrect = 14;
+inline void CorrectParamCfg::clear_ycorrect() {
+  _impl_.ycorrect_ = 0;
+}
+inline double CorrectParamCfg::ycorrect() const {
+  // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.ycorrect)
+  return _internal_ycorrect();
+}
+inline void CorrectParamCfg::set_ycorrect(double value) {
+  _internal_set_ycorrect(value);
+  // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.ycorrect)
+}
+inline double CorrectParamCfg::_internal_ycorrect() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.ycorrect_;
+}
+inline void CorrectParamCfg::_internal_set_ycorrect(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.ycorrect_ = value;
+}
+
+// double xcorrectMin = 15;
+inline void CorrectParamCfg::clear_xcorrectmin() {
+  _impl_.xcorrectmin_ = 0;
+}
+inline double CorrectParamCfg::xcorrectmin() const {
+  // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.xcorrectMin)
+  return _internal_xcorrectmin();
+}
+inline void CorrectParamCfg::set_xcorrectmin(double value) {
+  _internal_set_xcorrectmin(value);
+  // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.xcorrectMin)
+}
+inline double CorrectParamCfg::_internal_xcorrectmin() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.xcorrectmin_;
+}
+inline void CorrectParamCfg::_internal_set_xcorrectmin(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.xcorrectmin_ = value;
+}
+
+// double xcorrectMax = 16;
+inline void CorrectParamCfg::clear_xcorrectmax() {
+  _impl_.xcorrectmax_ = 0;
+}
+inline double CorrectParamCfg::xcorrectmax() const {
+  // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.xcorrectMax)
+  return _internal_xcorrectmax();
+}
+inline void CorrectParamCfg::set_xcorrectmax(double value) {
+  _internal_set_xcorrectmax(value);
+  // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.xcorrectMax)
+}
+inline double CorrectParamCfg::_internal_xcorrectmax() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.xcorrectmax_;
+}
+inline void CorrectParamCfg::_internal_set_xcorrectmax(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.xcorrectmax_ = value;
+}
+
+// double ycorrectMin = 17;
+inline void CorrectParamCfg::clear_ycorrectmin() {
+  _impl_.ycorrectmin_ = 0;
+}
+inline double CorrectParamCfg::ycorrectmin() const {
+  // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.ycorrectMin)
+  return _internal_ycorrectmin();
+}
+inline void CorrectParamCfg::set_ycorrectmin(double value) {
+  _internal_set_ycorrectmin(value);
+  // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.ycorrectMin)
+}
+inline double CorrectParamCfg::_internal_ycorrectmin() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.ycorrectmin_;
+}
+inline void CorrectParamCfg::_internal_set_ycorrectmin(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.ycorrectmin_ = value;
+}
+
+// double ycorrectMax = 18;
+inline void CorrectParamCfg::clear_ycorrectmax() {
+  _impl_.ycorrectmax_ = 0;
+}
+inline double CorrectParamCfg::ycorrectmax() const {
+  // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.ycorrectMax)
+  return _internal_ycorrectmax();
+}
+inline void CorrectParamCfg::set_ycorrectmax(double value) {
+  _internal_set_ycorrectmax(value);
+  // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.ycorrectMax)
+}
+inline double CorrectParamCfg::_internal_ycorrectmax() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.ycorrectmax_;
+}
+inline void CorrectParamCfg::_internal_set_ycorrectmax(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.ycorrectmax_ = value;
+}
+
+// double realXOffset = 19;
+inline void CorrectParamCfg::clear_realxoffset() {
+  _impl_.realxoffset_ = 0;
+}
+inline double CorrectParamCfg::realxoffset() const {
+  // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.realXOffset)
+  return _internal_realxoffset();
+}
+inline void CorrectParamCfg::set_realxoffset(double value) {
+  _internal_set_realxoffset(value);
+  // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.realXOffset)
+}
+inline double CorrectParamCfg::_internal_realxoffset() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.realxoffset_;
+}
+inline void CorrectParamCfg::_internal_set_realxoffset(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.realxoffset_ = value;
+}
+
+// double realYOffset = 20;
+inline void CorrectParamCfg::clear_realyoffset() {
+  _impl_.realyoffset_ = 0;
+}
+inline double CorrectParamCfg::realyoffset() const {
+  // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.realYOffset)
+  return _internal_realyoffset();
+}
+inline void CorrectParamCfg::set_realyoffset(double value) {
+  _internal_set_realyoffset(value);
+  // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.realYOffset)
+}
+inline double CorrectParamCfg::_internal_realyoffset() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.realyoffset_;
+}
+inline void CorrectParamCfg::_internal_set_realyoffset(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.realyoffset_ = value;
+}
+
+// double factorK = 21;
+inline void CorrectParamCfg::clear_factork() {
+  _impl_.factork_ = 0;
+}
+inline double CorrectParamCfg::factork() const {
+  // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.factorK)
+  return _internal_factork();
+}
+inline void CorrectParamCfg::set_factork(double value) {
+  _internal_set_factork(value);
+  // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.factorK)
+}
+inline double CorrectParamCfg::_internal_factork() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.factork_;
+}
+inline void CorrectParamCfg::_internal_set_factork(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.factork_ = value;
+}
+
+// bool isCorrectFile3D = 22;
+inline void CorrectParamCfg::clear_iscorrectfile3d() {
+  _impl_.iscorrectfile3d_ = false;
+}
+inline bool CorrectParamCfg::iscorrectfile3d() const {
+  // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.isCorrectFile3D)
+  return _internal_iscorrectfile3d();
+}
+inline void CorrectParamCfg::set_iscorrectfile3d(bool value) {
+  _internal_set_iscorrectfile3d(value);
+  // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.isCorrectFile3D)
+}
+inline bool CorrectParamCfg::_internal_iscorrectfile3d() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.iscorrectfile3d_;
+}
+inline void CorrectParamCfg::_internal_set_iscorrectfile3d(bool value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.iscorrectfile3d_ = value;
+}
+
+// bool isDynamicFocus = 23;
+inline void CorrectParamCfg::clear_isdynamicfocus() {
+  _impl_.isdynamicfocus_ = false;
+}
+inline bool CorrectParamCfg::isdynamicfocus() const {
+  // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.isDynamicFocus)
+  return _internal_isdynamicfocus();
+}
+inline void CorrectParamCfg::set_isdynamicfocus(bool value) {
+  _internal_set_isdynamicfocus(value);
+  // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.isDynamicFocus)
+}
+inline bool CorrectParamCfg::_internal_isdynamicfocus() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.isdynamicfocus_;
+}
+inline void CorrectParamCfg::_internal_set_isdynamicfocus(bool value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.isdynamicfocus_ = value;
+}
+
+// double defocusRatio = 24;
+inline void CorrectParamCfg::clear_defocusratio() {
+  _impl_.defocusratio_ = 0;
+}
+inline double CorrectParamCfg::defocusratio() const {
+  // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.defocusRatio)
+  return _internal_defocusratio();
+}
+inline void CorrectParamCfg::set_defocusratio(double value) {
+  _internal_set_defocusratio(value);
+  // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.defocusRatio)
+}
+inline double CorrectParamCfg::_internal_defocusratio() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.defocusratio_;
+}
+inline void CorrectParamCfg::_internal_set_defocusratio(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.defocusratio_ = value;
+}
+
+// double defocusRatioMin = 25;
+inline void CorrectParamCfg::clear_defocusratiomin() {
+  _impl_.defocusratiomin_ = 0;
+}
+inline double CorrectParamCfg::defocusratiomin() const {
+  // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.defocusRatioMin)
+  return _internal_defocusratiomin();
+}
+inline void CorrectParamCfg::set_defocusratiomin(double value) {
+  _internal_set_defocusratiomin(value);
+  // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.defocusRatioMin)
+}
+inline double CorrectParamCfg::_internal_defocusratiomin() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.defocusratiomin_;
+}
+inline void CorrectParamCfg::_internal_set_defocusratiomin(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.defocusratiomin_ = value;
+}
+
+// double defocusRatioMax = 26;
+inline void CorrectParamCfg::clear_defocusratiomax() {
+  _impl_.defocusratiomax_ = 0;
+}
+inline double CorrectParamCfg::defocusratiomax() const {
+  // @@protoc_insertion_point(field_get:stream.CorrectParamCfg.defocusRatioMax)
+  return _internal_defocusratiomax();
+}
+inline void CorrectParamCfg::set_defocusratiomax(double value) {
+  _internal_set_defocusratiomax(value);
+  // @@protoc_insertion_point(field_set:stream.CorrectParamCfg.defocusRatioMax)
+}
+inline double CorrectParamCfg::_internal_defocusratiomax() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.defocusratiomax_;
+}
+inline void CorrectParamCfg::_internal_set_defocusratiomax(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.defocusratiomax_ = value;
+}
+
+// -------------------------------------------------------------------
+
+// ScanTestCfg
+
+// int32 debugShape = 1;
+inline void ScanTestCfg::clear_debugshape() {
+  _impl_.debugshape_ = 0;
+}
+inline ::int32_t ScanTestCfg::debugshape() const {
+  // @@protoc_insertion_point(field_get:stream.ScanTestCfg.debugShape)
+  return _internal_debugshape();
+}
+inline void ScanTestCfg::set_debugshape(::int32_t value) {
+  _internal_set_debugshape(value);
+  // @@protoc_insertion_point(field_set:stream.ScanTestCfg.debugShape)
+}
+inline ::int32_t ScanTestCfg::_internal_debugshape() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.debugshape_;
+}
+inline void ScanTestCfg::_internal_set_debugshape(::int32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.debugshape_ = value;
+}
+
+// int32 shapeSize = 2;
+inline void ScanTestCfg::clear_shapesize() {
+  _impl_.shapesize_ = 0;
+}
+inline ::int32_t ScanTestCfg::shapesize() const {
+  // @@protoc_insertion_point(field_get:stream.ScanTestCfg.shapeSize)
+  return _internal_shapesize();
+}
+inline void ScanTestCfg::set_shapesize(::int32_t value) {
+  _internal_set_shapesize(value);
+  // @@protoc_insertion_point(field_set:stream.ScanTestCfg.shapeSize)
+}
+inline ::int32_t ScanTestCfg::_internal_shapesize() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.shapesize_;
+}
+inline void ScanTestCfg::_internal_set_shapesize(::int32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.shapesize_ = value;
+}
+
+// int32 shapeSizeMin = 3;
+inline void ScanTestCfg::clear_shapesizemin() {
+  _impl_.shapesizemin_ = 0;
+}
+inline ::int32_t ScanTestCfg::shapesizemin() const {
+  // @@protoc_insertion_point(field_get:stream.ScanTestCfg.shapeSizeMin)
+  return _internal_shapesizemin();
+}
+inline void ScanTestCfg::set_shapesizemin(::int32_t value) {
+  _internal_set_shapesizemin(value);
+  // @@protoc_insertion_point(field_set:stream.ScanTestCfg.shapeSizeMin)
+}
+inline ::int32_t ScanTestCfg::_internal_shapesizemin() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.shapesizemin_;
+}
+inline void ScanTestCfg::_internal_set_shapesizemin(::int32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.shapesizemin_ = value;
+}
+
+// int32 shape_size_max = 4;
+inline void ScanTestCfg::clear_shape_size_max() {
+  _impl_.shape_size_max_ = 0;
+}
+inline ::int32_t ScanTestCfg::shape_size_max() const {
+  // @@protoc_insertion_point(field_get:stream.ScanTestCfg.shape_size_max)
+  return _internal_shape_size_max();
+}
+inline void ScanTestCfg::set_shape_size_max(::int32_t value) {
+  _internal_set_shape_size_max(value);
+  // @@protoc_insertion_point(field_set:stream.ScanTestCfg.shape_size_max)
+}
+inline ::int32_t ScanTestCfg::_internal_shape_size_max() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.shape_size_max_;
+}
+inline void ScanTestCfg::_internal_set_shape_size_max(::int32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.shape_size_max_ = value;
+}
+
+// int32 laser_power = 5;
+inline void ScanTestCfg::clear_laser_power() {
+  _impl_.laser_power_ = 0;
+}
+inline ::int32_t ScanTestCfg::laser_power() const {
+  // @@protoc_insertion_point(field_get:stream.ScanTestCfg.laser_power)
+  return _internal_laser_power();
+}
+inline void ScanTestCfg::set_laser_power(::int32_t value) {
+  _internal_set_laser_power(value);
+  // @@protoc_insertion_point(field_set:stream.ScanTestCfg.laser_power)
+}
+inline ::int32_t ScanTestCfg::_internal_laser_power() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.laser_power_;
+}
+inline void ScanTestCfg::_internal_set_laser_power(::int32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.laser_power_ = value;
+}
+
+// int32 laser_power_min = 6;
+inline void ScanTestCfg::clear_laser_power_min() {
+  _impl_.laser_power_min_ = 0;
+}
+inline ::int32_t ScanTestCfg::laser_power_min() const {
+  // @@protoc_insertion_point(field_get:stream.ScanTestCfg.laser_power_min)
+  return _internal_laser_power_min();
+}
+inline void ScanTestCfg::set_laser_power_min(::int32_t value) {
+  _internal_set_laser_power_min(value);
+  // @@protoc_insertion_point(field_set:stream.ScanTestCfg.laser_power_min)
+}
+inline ::int32_t ScanTestCfg::_internal_laser_power_min() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.laser_power_min_;
+}
+inline void ScanTestCfg::_internal_set_laser_power_min(::int32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.laser_power_min_ = value;
+}
+
+// int32 laser_power_max = 7;
+inline void ScanTestCfg::clear_laser_power_max() {
+  _impl_.laser_power_max_ = 0;
+}
+inline ::int32_t ScanTestCfg::laser_power_max() const {
+  // @@protoc_insertion_point(field_get:stream.ScanTestCfg.laser_power_max)
+  return _internal_laser_power_max();
+}
+inline void ScanTestCfg::set_laser_power_max(::int32_t value) {
+  _internal_set_laser_power_max(value);
+  // @@protoc_insertion_point(field_set:stream.ScanTestCfg.laser_power_max)
+}
+inline ::int32_t ScanTestCfg::_internal_laser_power_max() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.laser_power_max_;
+}
+inline void ScanTestCfg::_internal_set_laser_power_max(::int32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.laser_power_max_ = value;
+}
+
+// double defocus = 8;
+inline void ScanTestCfg::clear_defocus() {
+  _impl_.defocus_ = 0;
+}
+inline double ScanTestCfg::defocus() const {
+  // @@protoc_insertion_point(field_get:stream.ScanTestCfg.defocus)
+  return _internal_defocus();
+}
+inline void ScanTestCfg::set_defocus(double value) {
+  _internal_set_defocus(value);
+  // @@protoc_insertion_point(field_set:stream.ScanTestCfg.defocus)
+}
+inline double ScanTestCfg::_internal_defocus() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.defocus_;
+}
+inline void ScanTestCfg::_internal_set_defocus(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.defocus_ = value;
+}
+
+// double defocus_min = 9;
+inline void ScanTestCfg::clear_defocus_min() {
+  _impl_.defocus_min_ = 0;
+}
+inline double ScanTestCfg::defocus_min() const {
+  // @@protoc_insertion_point(field_get:stream.ScanTestCfg.defocus_min)
+  return _internal_defocus_min();
+}
+inline void ScanTestCfg::set_defocus_min(double value) {
+  _internal_set_defocus_min(value);
+  // @@protoc_insertion_point(field_set:stream.ScanTestCfg.defocus_min)
+}
+inline double ScanTestCfg::_internal_defocus_min() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.defocus_min_;
+}
+inline void ScanTestCfg::_internal_set_defocus_min(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.defocus_min_ = value;
+}
+
+// double defocus_max = 10;
+inline void ScanTestCfg::clear_defocus_max() {
+  _impl_.defocus_max_ = 0;
+}
+inline double ScanTestCfg::defocus_max() const {
+  // @@protoc_insertion_point(field_get:stream.ScanTestCfg.defocus_max)
+  return _internal_defocus_max();
+}
+inline void ScanTestCfg::set_defocus_max(double value) {
+  _internal_set_defocus_max(value);
+  // @@protoc_insertion_point(field_set:stream.ScanTestCfg.defocus_max)
+}
+inline double ScanTestCfg::_internal_defocus_max() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.defocus_max_;
+}
+inline void ScanTestCfg::_internal_set_defocus_max(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.defocus_max_ = value;
+}
+
+// bool is_cycle = 11;
+inline void ScanTestCfg::clear_is_cycle() {
+  _impl_.is_cycle_ = false;
+}
+inline bool ScanTestCfg::is_cycle() const {
+  // @@protoc_insertion_point(field_get:stream.ScanTestCfg.is_cycle)
+  return _internal_is_cycle();
+}
+inline void ScanTestCfg::set_is_cycle(bool value) {
+  _internal_set_is_cycle(value);
+  // @@protoc_insertion_point(field_set:stream.ScanTestCfg.is_cycle)
+}
+inline bool ScanTestCfg::_internal_is_cycle() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.is_cycle_;
+}
+inline void ScanTestCfg::_internal_set_is_cycle(bool value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.is_cycle_ = value;
+}
+
+// double cross_x = 12;
+inline void ScanTestCfg::clear_cross_x() {
+  _impl_.cross_x_ = 0;
+}
+inline double ScanTestCfg::cross_x() const {
+  // @@protoc_insertion_point(field_get:stream.ScanTestCfg.cross_x)
+  return _internal_cross_x();
+}
+inline void ScanTestCfg::set_cross_x(double value) {
+  _internal_set_cross_x(value);
+  // @@protoc_insertion_point(field_set:stream.ScanTestCfg.cross_x)
+}
+inline double ScanTestCfg::_internal_cross_x() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.cross_x_;
+}
+inline void ScanTestCfg::_internal_set_cross_x(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.cross_x_ = value;
+}
+
+// double cross_y = 13;
+inline void ScanTestCfg::clear_cross_y() {
+  _impl_.cross_y_ = 0;
+}
+inline double ScanTestCfg::cross_y() const {
+  // @@protoc_insertion_point(field_get:stream.ScanTestCfg.cross_y)
+  return _internal_cross_y();
+}
+inline void ScanTestCfg::set_cross_y(double value) {
+  _internal_set_cross_y(value);
+  // @@protoc_insertion_point(field_set:stream.ScanTestCfg.cross_y)
+}
+inline double ScanTestCfg::_internal_cross_y() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.cross_y_;
+}
+inline void ScanTestCfg::_internal_set_cross_y(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.cross_y_ = value;
+}
+
+// double z_distance = 14;
+inline void ScanTestCfg::clear_z_distance() {
+  _impl_.z_distance_ = 0;
+}
+inline double ScanTestCfg::z_distance() const {
+  // @@protoc_insertion_point(field_get:stream.ScanTestCfg.z_distance)
+  return _internal_z_distance();
+}
+inline void ScanTestCfg::set_z_distance(double value) {
+  _internal_set_z_distance(value);
+  // @@protoc_insertion_point(field_set:stream.ScanTestCfg.z_distance)
+}
+inline double ScanTestCfg::_internal_z_distance() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.z_distance_;
+}
+inline void ScanTestCfg::_internal_set_z_distance(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.z_distance_ = value;
+}
+
+// bool isAutoHeatingScanner = 15;
+inline void ScanTestCfg::clear_isautoheatingscanner() {
+  _impl_.isautoheatingscanner_ = false;
+}
+inline bool ScanTestCfg::isautoheatingscanner() const {
+  // @@protoc_insertion_point(field_get:stream.ScanTestCfg.isAutoHeatingScanner)
+  return _internal_isautoheatingscanner();
+}
+inline void ScanTestCfg::set_isautoheatingscanner(bool value) {
+  _internal_set_isautoheatingscanner(value);
+  // @@protoc_insertion_point(field_set:stream.ScanTestCfg.isAutoHeatingScanner)
+}
+inline bool ScanTestCfg::_internal_isautoheatingscanner() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.isautoheatingscanner_;
+}
+inline void ScanTestCfg::_internal_set_isautoheatingscanner(bool value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.isautoheatingscanner_ = value;
+}
+
+// uint32 autoHeatingScannerMinutes = 16;
+inline void ScanTestCfg::clear_autoheatingscannerminutes() {
+  _impl_.autoheatingscannerminutes_ = 0u;
+}
+inline ::uint32_t ScanTestCfg::autoheatingscannerminutes() const {
+  // @@protoc_insertion_point(field_get:stream.ScanTestCfg.autoHeatingScannerMinutes)
+  return _internal_autoheatingscannerminutes();
+}
+inline void ScanTestCfg::set_autoheatingscannerminutes(::uint32_t value) {
+  _internal_set_autoheatingscannerminutes(value);
+  // @@protoc_insertion_point(field_set:stream.ScanTestCfg.autoHeatingScannerMinutes)
+}
+inline ::uint32_t ScanTestCfg::_internal_autoheatingscannerminutes() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.autoheatingscannerminutes_;
+}
+inline void ScanTestCfg::_internal_set_autoheatingscannerminutes(::uint32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.autoheatingscannerminutes_ = value;
+}
+
+// uint32 autoHeatingScannerSize = 17;
+inline void ScanTestCfg::clear_autoheatingscannersize() {
+  _impl_.autoheatingscannersize_ = 0u;
+}
+inline ::uint32_t ScanTestCfg::autoheatingscannersize() const {
+  // @@protoc_insertion_point(field_get:stream.ScanTestCfg.autoHeatingScannerSize)
+  return _internal_autoheatingscannersize();
+}
+inline void ScanTestCfg::set_autoheatingscannersize(::uint32_t value) {
+  _internal_set_autoheatingscannersize(value);
+  // @@protoc_insertion_point(field_set:stream.ScanTestCfg.autoHeatingScannerSize)
+}
+inline ::uint32_t ScanTestCfg::_internal_autoheatingscannersize() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.autoheatingscannersize_;
+}
+inline void ScanTestCfg::_internal_set_autoheatingscannersize(::uint32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.autoheatingscannersize_ = value;
+}
+
+// double autoHeatingScannerSpeed = 18;
+inline void ScanTestCfg::clear_autoheatingscannerspeed() {
+  _impl_.autoheatingscannerspeed_ = 0;
+}
+inline double ScanTestCfg::autoheatingscannerspeed() const {
+  // @@protoc_insertion_point(field_get:stream.ScanTestCfg.autoHeatingScannerSpeed)
+  return _internal_autoheatingscannerspeed();
+}
+inline void ScanTestCfg::set_autoheatingscannerspeed(double value) {
+  _internal_set_autoheatingscannerspeed(value);
+  // @@protoc_insertion_point(field_set:stream.ScanTestCfg.autoHeatingScannerSpeed)
+}
+inline double ScanTestCfg::_internal_autoheatingscannerspeed() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.autoheatingscannerspeed_;
+}
+inline void ScanTestCfg::_internal_set_autoheatingscannerspeed(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.autoheatingscannerspeed_ = value;
+}
+
+// double mark_test_start_x = 19;
+inline void ScanTestCfg::clear_mark_test_start_x() {
+  _impl_.mark_test_start_x_ = 0;
+}
+inline double ScanTestCfg::mark_test_start_x() const {
+  // @@protoc_insertion_point(field_get:stream.ScanTestCfg.mark_test_start_x)
+  return _internal_mark_test_start_x();
+}
+inline void ScanTestCfg::set_mark_test_start_x(double value) {
+  _internal_set_mark_test_start_x(value);
+  // @@protoc_insertion_point(field_set:stream.ScanTestCfg.mark_test_start_x)
+}
+inline double ScanTestCfg::_internal_mark_test_start_x() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.mark_test_start_x_;
+}
+inline void ScanTestCfg::_internal_set_mark_test_start_x(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.mark_test_start_x_ = value;
+}
+
+// double mark_test_start_y = 20;
+inline void ScanTestCfg::clear_mark_test_start_y() {
+  _impl_.mark_test_start_y_ = 0;
+}
+inline double ScanTestCfg::mark_test_start_y() const {
+  // @@protoc_insertion_point(field_get:stream.ScanTestCfg.mark_test_start_y)
+  return _internal_mark_test_start_y();
+}
+inline void ScanTestCfg::set_mark_test_start_y(double value) {
+  _internal_set_mark_test_start_y(value);
+  // @@protoc_insertion_point(field_set:stream.ScanTestCfg.mark_test_start_y)
+}
+inline double ScanTestCfg::_internal_mark_test_start_y() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.mark_test_start_y_;
+}
+inline void ScanTestCfg::_internal_set_mark_test_start_y(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.mark_test_start_y_ = value;
+}
+
+// double mark_test_end_x = 21;
+inline void ScanTestCfg::clear_mark_test_end_x() {
+  _impl_.mark_test_end_x_ = 0;
+}
+inline double ScanTestCfg::mark_test_end_x() const {
+  // @@protoc_insertion_point(field_get:stream.ScanTestCfg.mark_test_end_x)
+  return _internal_mark_test_end_x();
+}
+inline void ScanTestCfg::set_mark_test_end_x(double value) {
+  _internal_set_mark_test_end_x(value);
+  // @@protoc_insertion_point(field_set:stream.ScanTestCfg.mark_test_end_x)
+}
+inline double ScanTestCfg::_internal_mark_test_end_x() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.mark_test_end_x_;
+}
+inline void ScanTestCfg::_internal_set_mark_test_end_x(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.mark_test_end_x_ = value;
+}
+
+// double mark_test_end_y = 22;
+inline void ScanTestCfg::clear_mark_test_end_y() {
+  _impl_.mark_test_end_y_ = 0;
+}
+inline double ScanTestCfg::mark_test_end_y() const {
+  // @@protoc_insertion_point(field_get:stream.ScanTestCfg.mark_test_end_y)
+  return _internal_mark_test_end_y();
+}
+inline void ScanTestCfg::set_mark_test_end_y(double value) {
+  _internal_set_mark_test_end_y(value);
+  // @@protoc_insertion_point(field_set:stream.ScanTestCfg.mark_test_end_y)
+}
+inline double ScanTestCfg::_internal_mark_test_end_y() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.mark_test_end_y_;
+}
+inline void ScanTestCfg::_internal_set_mark_test_end_y(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.mark_test_end_y_ = value;
+}
+
+// -------------------------------------------------------------------
+
+// SkyWritingCfg
+
+// bool isEnable = 1;
+inline void SkyWritingCfg::clear_isenable() {
+  _impl_.isenable_ = false;
+}
+inline bool SkyWritingCfg::isenable() const {
+  // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.isEnable)
+  return _internal_isenable();
+}
+inline void SkyWritingCfg::set_isenable(bool value) {
+  _internal_set_isenable(value);
+  // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.isEnable)
+}
+inline bool SkyWritingCfg::_internal_isenable() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.isenable_;
+}
+inline void SkyWritingCfg::_internal_set_isenable(bool value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.isenable_ = value;
+}
+
+// double timelag = 2;
+inline void SkyWritingCfg::clear_timelag() {
+  _impl_.timelag_ = 0;
+}
+inline double SkyWritingCfg::timelag() const {
+  // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.timelag)
+  return _internal_timelag();
+}
+inline void SkyWritingCfg::set_timelag(double value) {
+  _internal_set_timelag(value);
+  // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.timelag)
+}
+inline double SkyWritingCfg::_internal_timelag() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.timelag_;
+}
+inline void SkyWritingCfg::_internal_set_timelag(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.timelag_ = value;
+}
+
+// double timelagMin = 3;
+inline void SkyWritingCfg::clear_timelagmin() {
+  _impl_.timelagmin_ = 0;
+}
+inline double SkyWritingCfg::timelagmin() const {
+  // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.timelagMin)
+  return _internal_timelagmin();
+}
+inline void SkyWritingCfg::set_timelagmin(double value) {
+  _internal_set_timelagmin(value);
+  // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.timelagMin)
+}
+inline double SkyWritingCfg::_internal_timelagmin() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.timelagmin_;
+}
+inline void SkyWritingCfg::_internal_set_timelagmin(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.timelagmin_ = value;
+}
+
+// double timelagMax = 4;
+inline void SkyWritingCfg::clear_timelagmax() {
+  _impl_.timelagmax_ = 0;
+}
+inline double SkyWritingCfg::timelagmax() const {
+  // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.timelagMax)
+  return _internal_timelagmax();
+}
+inline void SkyWritingCfg::set_timelagmax(double value) {
+  _internal_set_timelagmax(value);
+  // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.timelagMax)
+}
+inline double SkyWritingCfg::_internal_timelagmax() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.timelagmax_;
+}
+inline void SkyWritingCfg::_internal_set_timelagmax(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.timelagmax_ = value;
+}
+
+// int64 laserOnShift = 5;
+inline void SkyWritingCfg::clear_laseronshift() {
+  _impl_.laseronshift_ = ::int64_t{0};
+}
+inline ::int64_t SkyWritingCfg::laseronshift() const {
+  // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.laserOnShift)
+  return _internal_laseronshift();
+}
+inline void SkyWritingCfg::set_laseronshift(::int64_t value) {
+  _internal_set_laseronshift(value);
+  // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.laserOnShift)
+}
+inline ::int64_t SkyWritingCfg::_internal_laseronshift() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.laseronshift_;
+}
+inline void SkyWritingCfg::_internal_set_laseronshift(::int64_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.laseronshift_ = value;
+}
+
+// int64 laserOnShiftMin = 6;
+inline void SkyWritingCfg::clear_laseronshiftmin() {
+  _impl_.laseronshiftmin_ = ::int64_t{0};
+}
+inline ::int64_t SkyWritingCfg::laseronshiftmin() const {
+  // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.laserOnShiftMin)
+  return _internal_laseronshiftmin();
+}
+inline void SkyWritingCfg::set_laseronshiftmin(::int64_t value) {
+  _internal_set_laseronshiftmin(value);
+  // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.laserOnShiftMin)
+}
+inline ::int64_t SkyWritingCfg::_internal_laseronshiftmin() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.laseronshiftmin_;
+}
+inline void SkyWritingCfg::_internal_set_laseronshiftmin(::int64_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.laseronshiftmin_ = value;
+}
+
+// int64 laserOnShiftMax = 7;
+inline void SkyWritingCfg::clear_laseronshiftmax() {
+  _impl_.laseronshiftmax_ = ::int64_t{0};
+}
+inline ::int64_t SkyWritingCfg::laseronshiftmax() const {
+  // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.laserOnShiftMax)
+  return _internal_laseronshiftmax();
+}
+inline void SkyWritingCfg::set_laseronshiftmax(::int64_t value) {
+  _internal_set_laseronshiftmax(value);
+  // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.laserOnShiftMax)
+}
+inline ::int64_t SkyWritingCfg::_internal_laseronshiftmax() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.laseronshiftmax_;
+}
+inline void SkyWritingCfg::_internal_set_laseronshiftmax(::int64_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.laseronshiftmax_ = value;
+}
+
+// uint32 nprev = 8;
+inline void SkyWritingCfg::clear_nprev() {
+  _impl_.nprev_ = 0u;
+}
+inline ::uint32_t SkyWritingCfg::nprev() const {
+  // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.nprev)
+  return _internal_nprev();
+}
+inline void SkyWritingCfg::set_nprev(::uint32_t value) {
+  _internal_set_nprev(value);
+  // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.nprev)
+}
+inline ::uint32_t SkyWritingCfg::_internal_nprev() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.nprev_;
+}
+inline void SkyWritingCfg::_internal_set_nprev(::uint32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.nprev_ = value;
+}
+
+// uint32 nprevMin = 9;
+inline void SkyWritingCfg::clear_nprevmin() {
+  _impl_.nprevmin_ = 0u;
+}
+inline ::uint32_t SkyWritingCfg::nprevmin() const {
+  // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.nprevMin)
+  return _internal_nprevmin();
+}
+inline void SkyWritingCfg::set_nprevmin(::uint32_t value) {
+  _internal_set_nprevmin(value);
+  // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.nprevMin)
+}
+inline ::uint32_t SkyWritingCfg::_internal_nprevmin() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.nprevmin_;
+}
+inline void SkyWritingCfg::_internal_set_nprevmin(::uint32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.nprevmin_ = value;
+}
+
+// uint32 nprevMax = 10;
+inline void SkyWritingCfg::clear_nprevmax() {
+  _impl_.nprevmax_ = 0u;
+}
+inline ::uint32_t SkyWritingCfg::nprevmax() const {
+  // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.nprevMax)
+  return _internal_nprevmax();
+}
+inline void SkyWritingCfg::set_nprevmax(::uint32_t value) {
+  _internal_set_nprevmax(value);
+  // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.nprevMax)
+}
+inline ::uint32_t SkyWritingCfg::_internal_nprevmax() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.nprevmax_;
+}
+inline void SkyWritingCfg::_internal_set_nprevmax(::uint32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.nprevmax_ = value;
+}
+
+// uint32 npost = 11;
+inline void SkyWritingCfg::clear_npost() {
+  _impl_.npost_ = 0u;
+}
+inline ::uint32_t SkyWritingCfg::npost() const {
+  // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.npost)
+  return _internal_npost();
+}
+inline void SkyWritingCfg::set_npost(::uint32_t value) {
+  _internal_set_npost(value);
+  // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.npost)
+}
+inline ::uint32_t SkyWritingCfg::_internal_npost() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.npost_;
+}
+inline void SkyWritingCfg::_internal_set_npost(::uint32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.npost_ = value;
+}
+
+// uint32 npostMin = 12;
+inline void SkyWritingCfg::clear_npostmin() {
+  _impl_.npostmin_ = 0u;
+}
+inline ::uint32_t SkyWritingCfg::npostmin() const {
+  // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.npostMin)
+  return _internal_npostmin();
+}
+inline void SkyWritingCfg::set_npostmin(::uint32_t value) {
+  _internal_set_npostmin(value);
+  // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.npostMin)
+}
+inline ::uint32_t SkyWritingCfg::_internal_npostmin() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.npostmin_;
+}
+inline void SkyWritingCfg::_internal_set_npostmin(::uint32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.npostmin_ = value;
+}
+
+// uint32 npostMax = 13;
+inline void SkyWritingCfg::clear_npostmax() {
+  _impl_.npostmax_ = 0u;
+}
+inline ::uint32_t SkyWritingCfg::npostmax() const {
+  // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.npostMax)
+  return _internal_npostmax();
+}
+inline void SkyWritingCfg::set_npostmax(::uint32_t value) {
+  _internal_set_npostmax(value);
+  // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.npostMax)
+}
+inline ::uint32_t SkyWritingCfg::_internal_npostmax() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.npostmax_;
+}
+inline void SkyWritingCfg::_internal_set_npostmax(::uint32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.npostmax_ = value;
+}
+
+// int32 mode = 14;
+inline void SkyWritingCfg::clear_mode() {
+  _impl_.mode_ = 0;
+}
+inline ::int32_t SkyWritingCfg::mode() const {
+  // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.mode)
+  return _internal_mode();
+}
+inline void SkyWritingCfg::set_mode(::int32_t value) {
+  _internal_set_mode(value);
+  // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.mode)
+}
+inline ::int32_t SkyWritingCfg::_internal_mode() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.mode_;
+}
+inline void SkyWritingCfg::_internal_set_mode(::int32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.mode_ = value;
+}
+
+// double limite = 15;
+inline void SkyWritingCfg::clear_limite() {
+  _impl_.limite_ = 0;
+}
+inline double SkyWritingCfg::limite() const {
+  // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.limite)
+  return _internal_limite();
+}
+inline void SkyWritingCfg::set_limite(double value) {
+  _internal_set_limite(value);
+  // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.limite)
+}
+inline double SkyWritingCfg::_internal_limite() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.limite_;
+}
+inline void SkyWritingCfg::_internal_set_limite(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.limite_ = value;
+}
+
+// double limiteMin = 16;
+inline void SkyWritingCfg::clear_limitemin() {
+  _impl_.limitemin_ = 0;
+}
+inline double SkyWritingCfg::limitemin() const {
+  // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.limiteMin)
+  return _internal_limitemin();
+}
+inline void SkyWritingCfg::set_limitemin(double value) {
+  _internal_set_limitemin(value);
+  // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.limiteMin)
+}
+inline double SkyWritingCfg::_internal_limitemin() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.limitemin_;
+}
+inline void SkyWritingCfg::_internal_set_limitemin(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.limitemin_ = value;
+}
+
+// double limiteMax = 17;
+inline void SkyWritingCfg::clear_limitemax() {
+  _impl_.limitemax_ = 0;
+}
+inline double SkyWritingCfg::limitemax() const {
+  // @@protoc_insertion_point(field_get:stream.SkyWritingCfg.limiteMax)
+  return _internal_limitemax();
+}
+inline void SkyWritingCfg::set_limitemax(double value) {
+  _internal_set_limitemax(value);
+  // @@protoc_insertion_point(field_set:stream.SkyWritingCfg.limiteMax)
+}
+inline double SkyWritingCfg::_internal_limitemax() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.limitemax_;
+}
+inline void SkyWritingCfg::_internal_set_limitemax(double value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.limitemax_ = value;
+}
+
+// -------------------------------------------------------------------
+
+// PowerCompensate
+
+// int32 cno = 1;
+inline void PowerCompensate::clear_cno() {
+  _impl_.cno_ = 0;
+}
+inline ::int32_t PowerCompensate::cno() const {
+  // @@protoc_insertion_point(field_get:stream.PowerCompensate.cno)
+  return _internal_cno();
+}
+inline void PowerCompensate::set_cno(::int32_t value) {
+  _internal_set_cno(value);
+  // @@protoc_insertion_point(field_set:stream.PowerCompensate.cno)
+}
+inline ::int32_t PowerCompensate::_internal_cno() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.cno_;
+}
+inline void PowerCompensate::_internal_set_cno(::int32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.cno_ = value;
+}
+
+// int32 percent = 2;
+inline void PowerCompensate::clear_percent() {
+  _impl_.percent_ = 0;
+}
+inline ::int32_t PowerCompensate::percent() const {
+  // @@protoc_insertion_point(field_get:stream.PowerCompensate.percent)
+  return _internal_percent();
+}
+inline void PowerCompensate::set_percent(::int32_t value) {
+  _internal_set_percent(value);
+  // @@protoc_insertion_point(field_set:stream.PowerCompensate.percent)
+}
+inline ::int32_t PowerCompensate::_internal_percent() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.percent_;
+}
+inline void PowerCompensate::_internal_set_percent(::int32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.percent_ = value;
+}
+
+// float value = 3;
+inline void PowerCompensate::clear_value() {
+  _impl_.value_ = 0;
+}
+inline float PowerCompensate::value() const {
+  // @@protoc_insertion_point(field_get:stream.PowerCompensate.value)
+  return _internal_value();
+}
+inline void PowerCompensate::set_value(float value) {
+  _internal_set_value(value);
+  // @@protoc_insertion_point(field_set:stream.PowerCompensate.value)
+}
+inline float PowerCompensate::_internal_value() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.value_;
+}
+inline void PowerCompensate::_internal_set_value(float value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.value_ = value;
+}
+
+// float value_min = 4;
+inline void PowerCompensate::clear_value_min() {
+  _impl_.value_min_ = 0;
+}
+inline float PowerCompensate::value_min() const {
+  // @@protoc_insertion_point(field_get:stream.PowerCompensate.value_min)
+  return _internal_value_min();
+}
+inline void PowerCompensate::set_value_min(float value) {
+  _internal_set_value_min(value);
+  // @@protoc_insertion_point(field_set:stream.PowerCompensate.value_min)
+}
+inline float PowerCompensate::_internal_value_min() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.value_min_;
+}
+inline void PowerCompensate::_internal_set_value_min(float value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.value_min_ = value;
+}
+
+// float value_max = 5;
+inline void PowerCompensate::clear_value_max() {
+  _impl_.value_max_ = 0;
+}
+inline float PowerCompensate::value_max() const {
+  // @@protoc_insertion_point(field_get:stream.PowerCompensate.value_max)
+  return _internal_value_max();
+}
+inline void PowerCompensate::set_value_max(float value) {
+  _internal_set_value_max(value);
+  // @@protoc_insertion_point(field_set:stream.PowerCompensate.value_max)
+}
+inline float PowerCompensate::_internal_value_max() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.value_max_;
+}
+inline void PowerCompensate::_internal_set_value_max(float value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.value_max_ = value;
+}
+
+// -------------------------------------------------------------------
+
+// TimePowerCompensate
+
+// int32 id = 1;
+inline void TimePowerCompensate::clear_id() {
+  _impl_.id_ = 0;
+}
+inline ::int32_t TimePowerCompensate::id() const {
+  // @@protoc_insertion_point(field_get:stream.TimePowerCompensate.id)
+  return _internal_id();
+}
+inline void TimePowerCompensate::set_id(::int32_t value) {
+  _internal_set_id(value);
+  // @@protoc_insertion_point(field_set:stream.TimePowerCompensate.id)
+}
+inline ::int32_t TimePowerCompensate::_internal_id() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.id_;
+}
+inline void TimePowerCompensate::_internal_set_id(::int32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.id_ = value;
+}
+
+// int32 cno = 2;
+inline void TimePowerCompensate::clear_cno() {
+  _impl_.cno_ = 0;
+}
+inline ::int32_t TimePowerCompensate::cno() const {
+  // @@protoc_insertion_point(field_get:stream.TimePowerCompensate.cno)
+  return _internal_cno();
+}
+inline void TimePowerCompensate::set_cno(::int32_t value) {
+  _internal_set_cno(value);
+  // @@protoc_insertion_point(field_set:stream.TimePowerCompensate.cno)
+}
+inline ::int32_t TimePowerCompensate::_internal_cno() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.cno_;
+}
+inline void TimePowerCompensate::_internal_set_cno(::int32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.cno_ = value;
+}
+
+// uint32 startMinute = 3;
+inline void TimePowerCompensate::clear_startminute() {
+  _impl_.startminute_ = 0u;
+}
+inline ::uint32_t TimePowerCompensate::startminute() const {
+  // @@protoc_insertion_point(field_get:stream.TimePowerCompensate.startMinute)
+  return _internal_startminute();
+}
+inline void TimePowerCompensate::set_startminute(::uint32_t value) {
+  _internal_set_startminute(value);
+  // @@protoc_insertion_point(field_set:stream.TimePowerCompensate.startMinute)
+}
+inline ::uint32_t TimePowerCompensate::_internal_startminute() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.startminute_;
+}
+inline void TimePowerCompensate::_internal_set_startminute(::uint32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.startminute_ = value;
+}
+
+// uint32 endMinute = 4;
+inline void TimePowerCompensate::clear_endminute() {
+  _impl_.endminute_ = 0u;
+}
+inline ::uint32_t TimePowerCompensate::endminute() const {
+  // @@protoc_insertion_point(field_get:stream.TimePowerCompensate.endMinute)
+  return _internal_endminute();
+}
+inline void TimePowerCompensate::set_endminute(::uint32_t value) {
+  _internal_set_endminute(value);
+  // @@protoc_insertion_point(field_set:stream.TimePowerCompensate.endMinute)
+}
+inline ::uint32_t TimePowerCompensate::_internal_endminute() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.endminute_;
+}
+inline void TimePowerCompensate::_internal_set_endminute(::uint32_t value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.endminute_ = value;
+}
+
+// float compensate = 5;
+inline void TimePowerCompensate::clear_compensate() {
+  _impl_.compensate_ = 0;
+}
+inline float TimePowerCompensate::compensate() const {
+  // @@protoc_insertion_point(field_get:stream.TimePowerCompensate.compensate)
+  return _internal_compensate();
+}
+inline void TimePowerCompensate::set_compensate(float value) {
+  _internal_set_compensate(value);
+  // @@protoc_insertion_point(field_set:stream.TimePowerCompensate.compensate)
+}
+inline float TimePowerCompensate::_internal_compensate() const {
+  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
+  return _impl_.compensate_;
+}
+inline void TimePowerCompensate::_internal_set_compensate(float value) {
+  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
+  ;
+  _impl_.compensate_ = value;
+}
+
 #ifdef __GNUC__
 #pragma GCC diagnostic pop
 #endif  // __GNUC__
diff --git a/TestClient/protobuf/stream.proto b/TestClient/protobuf/stream.proto
index f9108a4..a1514b9 100644
--- a/TestClient/protobuf/stream.proto
+++ b/TestClient/protobuf/stream.proto
@@ -37,7 +37,7 @@ enum DATAHANDLE {
 
 message ParamInfo{
     bytes  nameKey = 1;   //参数key
-    bytes  strValue = 2;  //value
+    bytes  strValue = 2;    //value
     TYPE  valueType = 3;  //数据类型
 
 	bytes context = 4;    //alarmcfg 使用
@@ -48,6 +48,15 @@ message ParamInfo{
 	int32 startLayer = 8;   //层供粉量配置使用  struct PowderSet
     int32 endLayer = 9;
     float powder = 10;
+
+	int32 seqNo = 11;   //ScannerControlCfg使用
+    int32 controlNo = 12;
+    int32 serialNo = 13;
+    int32 controlType = 14;
+    bytes cardName = 15;
+    bytes cardIP = 16;
+    bool hadAssign = 17;
+    bool hadMatch = 18;   //isEnable公用
 }
 
 message RequestInfo {   //读
@@ -135,6 +144,168 @@ message ComResponce{
 	bytes  data = 1;
 }
 
+//ScannerCrtlCfg结构体
+message ScannerCrtlCfgResp{
+	repeated ScannerCrtlCfgData scannerCfg = 1;
+}
+
+message ScannerCrtlCfgData{
+	int32 seqNo = 1;
+	repeated FixPointData fixPointData = 2;
+	ScanParamCfg scanParamCfg = 3;
+	ScanParamCfg  hatchingParams = 4;
+	ScanParamCfg  borderParams = 5;
+	ScanParamCfg  supportParams = 6;
+	CorrectParamCfg  correctParamCfg = 7;
+	ScanTestCfg  scanTestCfg = 8;
+	SkyWritingCfg skyWritingCfg = 9;
+	repeated PowerCompensate powerCompensate = 10;
+	repeated TimePowerCompensate tPowerCompensate = 11;
+
+	int32 controlNo = 12;
+	int32 serialNo = 13;
+	int32 controlType = 14;
+	bytes cardName = 15;
+	bytes cardIP = 16;
+	bool isEnable = 17;				//是否启动
+	bool hadAssign = 18;
+	bool hadMatch = 19;
+}
+
+message FixPointData{
+	int32 id = 1;
+	int32 cno = 2;
+	float pointX = 3;
+	float pointY = 4;
+	uint32 duration = 5;
+}
+
+
+
+message ScanParamCfg{
+	int32 edgeLevel = 1;
+	int32 edgeLevelMin = 2;
+	int32 edgeLevelMax = 3;
+	uint32 jumpDelay = 4;
+	uint32 jumpDelayMin = 5;
+	uint32 jumpDelayMax = 6;
+	uint32 scanDelay = 7;
+	uint32 scanDelayMin = 8;
+	uint32 scanDelayMax = 9;
+	uint32 polygonDelay = 10;
+	uint32 polygonDelayMin = 11;
+	uint32 polygonDelayMax = 12;
+	int64 laseroffDelay = 13;
+	int64 laseroffDelayMin = 14;
+	int64 laseroffDelayMax = 15;
+	int64 laseronDelay = 16;
+	int64 laseronDelayMin = 17;
+	int64 laseronDelayMax = 18;
+	uint32 minJumpDelay = 19;
+	uint32 minJumpDelayMin = 20;
+	uint32  minJumpDelayMax = 21;
+	uint32  jumpLengthLimit = 22;
+	uint32  jumpLengthLimitMin = 23;
+	uint32  jumpLengthLimitMax = 24;
+	double  jumpSpeed = 25;
+	double  jumpSpeedMin = 26;
+	double  jumpSpeedMax = 27;
+	double  markSpeed = 28;
+	double  markSpeedMin = 29;
+	double  markSpeedMax = 30;
+}
+
+message CorrectParamCfg{
+	double xmeasureMin = 1;			//x可打印最小位置
+	double xmeasureMax = 2;			//x可打印最大位置
+	double ymeasureMin = 3;			//y可打印最小位置
+	double ymeasureMax = 4;			//y可打印最大位置
+	double xposfix = 5;				//x位置修正
+	double yposfix = 6;				//y位置修正
+	double scanAngle = 7;					//旋转角度  逆时针
+	double scanAngleMin = 8;
+	double scanAngleMax = 9;
+	double fixAngle = 10;					//旋转角度  逆时针
+	double fixAngleMin = 11;
+	double fixAngleMax = 12;
+	double xcorrect = 13;				//x尺寸修正
+	double ycorrect = 14;				//y尺寸修正
+	double xcorrectMin = 15;
+	double xcorrectMax = 16;
+	double ycorrectMin = 17;
+	double ycorrectMax = 18;
+	double realXOffset = 19;
+	double realYOffset = 20;
+	double factorK = 21;
+	bool isCorrectFile3D = 22;
+	bool isDynamicFocus = 23;		//是否动态聚焦
+	double defocusRatio = 24;		//离焦比
+	double defocusRatioMin = 25;
+	double defocusRatioMax = 26;
+}
+
+message ScanTestCfg{
+	int32 debugShape = 1;
+	int32 shapeSize = 2;
+	int32 shapeSizeMin = 3;
+	int32  shape_size_max = 4;
+	int32  laser_power = 5;
+	int32  laser_power_min = 6;
+	int32  laser_power_max = 7;
+	double  defocus = 8;
+	double  defocus_min = 9;
+	double  defocus_max = 10;
+	bool    is_cycle = 11;
+	double  cross_x = 12;
+	double  cross_y = 13;
+	double  z_distance = 14;
+	bool  isAutoHeatingScanner = 15;		//开启暂停开始时预热振镜
+	uint32  autoHeatingScannerMinutes = 16;
+	uint32  autoHeatingScannerSize = 17;
+	double  autoHeatingScannerSpeed = 18;
+	double  mark_test_start_x = 19;
+	double  mark_test_start_y = 20;
+	double  mark_test_end_x = 21;
+	double  mark_test_end_y = 22;
+}
+
+message SkyWritingCfg{
+	bool isEnable = 1;
+	double timelag = 2;
+	double timelagMin = 3;
+	double timelagMax = 4;
+	int64 laserOnShift = 5;
+	int64 laserOnShiftMin = 6;
+	int64 laserOnShiftMax = 7;
+	uint32  nprev = 8;
+	uint32 nprevMin =9;
+	uint32 nprevMax = 10;
+	uint32 npost = 11;
+	uint32 npostMin = 12;
+	uint32 npostMax = 13;
+	int32 mode = 14;
+	double limite = 15;
+	double limiteMin = 16;
+	double limiteMax = 17;
+}
+
+
+message PowerCompensate{
+	int32 cno = 1;
+	int32 percent = 2;
+	float value = 3;
+	float value_min = 4;
+	float value_max = 5;
+}
+
+message TimePowerCompensate{
+	int32 id = 1;
+	int32 cno = 2;
+	uint32 startMinute = 3;
+	uint32 endMinute = 4;
+	float compensate = 5;
+}
+
 service Stream {
   rpc Simple(RequestInfo) returns (ResponseAny) {} // 简单模式
   rpc ServerStream (RequestInfo) returns (stream ResponseInfo) {} // 服务端数据流模式