[ { "path": "BM(C++)/BM.cpp", "content": "/* ˫Ŀ */\r\n\r\n#include \r\n#include \r\n#include \r\n\r\nusing namespace std;\r\nusing namespace cv;\r\n\r\nconst int imageWidth = 640; //ͷķֱ \r\nconst int imageHeight = 480;\r\nVec3f point3;\r\nfloat d;\r\nSize imageSize = Size(imageWidth, imageHeight);\r\n\r\nMat img;\r\nMat rgbImageL, grayImageL;\r\nMat rgbImageR, grayImageR;\r\nMat rectifyImageL, rectifyImageR;\r\nRect m_l_select;\r\nRect m_r_select;\r\n\r\nRect validROIL;//ͼУ֮󣬻ͼвüvalidROIָü֮ \r\nRect validROIR;\r\n\r\nMat mapLx, mapLy, mapRx, mapRy; //ӳ \r\nMat Rl, Rr, Pl, Pr, Q; //УתRͶӰP ͶӰQ\r\nMat xyz; //ά\r\n\r\nPoint origin; //갴µʼ\r\nRect selection; //ѡ\r\nbool selectObject = false; //Ƿѡ\r\n\r\n\r\n\r\n\r\nint blockSize = 8, uniquenessRatio = 0, numDisparities = 3;\r\nPtr bm = StereoBM::create(16, 9);\r\n\r\n/*ȱ궨õڲξ\r\nfx 0 cx\r\n0 fy cy\r\n0 0 1\r\n*/\r\nMat cameraMatrixL = (Mat_(3, 3) << 516.5066236, -1.444673028, 320.2950423, 0, 516.5816117, 270.7881873, 0, 0, 1.);\r\n//õĻ\r\n\r\n\r\n\r\n/*418.523322187048\t0\t0\r\n-1.26842201390676\t421.222568242056\t0\r\n344.758267538961\t243.318992284899\t1 */ //2\r\n\r\nMat distCoeffL = (Mat_(5, 1) << -0.046645194, 0.077595167, 0.012476819, -0.000711358, 0);\r\n//[0.006636837611004,0.050240447649195] [0.006681263320267,0.003130367429418]\r\n\r\n\r\n/*ȱ궨õڲξ\r\nfx 0 cx\r\n0 fy cy\r\n0 0 1\r\n*/\r\nMat cameraMatrixR = (Mat_(3, 3) << 511.8428182, 1.295112628, 317.310253, 0, 513.0748795, 269.5885026,0, 0, 1);\r\n\r\n\r\n/*\r\n417.417985082506\t0\t0\r\n0.498638151824367\t419.795432389420\t0\r\n309.903372309072\t236.256106972796\t1\r\n*/ //2\r\n\r\n\r\nMat distCoeffR = (Mat_(5, 1) << -0.061588946, 0.122384376, 0.011081232, -0.000750439, 0);\r\n//[-0.038407383078874,0.236392800301615] [0.004121779274885,0.002296129959664]\r\n\r\n\r\n\r\nMat T = (Mat_(3, 1) <<-120.3559901,-0.188953775,-0.662073075);//Tƽ\r\n//[-1.210187345641146e+02,0.519235426836325,-0.425535566316217]\r\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t //ӦMatlabT\r\n//Mat rec = (Mat_(3, 1) << -0.00306, -0.03207, 0.00206);//recתӦmatlab om \r\nMat rec = (Mat_(3, 3) << 0.999911333, -0.004351508, 0.012585312,\r\n\t0.004184066, 0.999902792, 0.013300386,\r\n\t-0.012641965, -0.013246549, 0.999832341); //recתӦmatlab om \r\n\r\n/* 0.999341122700880\t0.000660748031451783\t-0.0362888948713456\r\n-0.00206388651740061\t0.999250989651683\t-0.0386419468010579\r\n0.0362361815232777\t0.0386913826603732\t0.998593969567432 */\r\n\r\n//Mat T = (Mat_(3, 1) << -48.4, 0.241, -0.0344);//Tƽ\r\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t //[-1.210187345641146e+02,0.519235426836325,-0.425535566316217]\r\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t //ӦMatlabT\r\n\r\nMat R;//R ת\r\n\r\n\r\n\t /*****ƥ*****/\r\nvoid stereo_match(int, void*)\r\n{\r\n\tbm->setBlockSize(2 * blockSize + 5); //SADڴС5~21֮Ϊ\r\n\tbm->setROI1(validROIL);\r\n\tbm->setROI2(validROIR);\r\n\tbm->setPreFilterCap(31);\r\n\tbm->setMinDisparity(0); //СӲĬֵΪ0, Ǹֵint\r\n\tbm->setNumDisparities(numDisparities * 16 + 16);//ӲڣӲֵСӲֵ֮,ڴС16int\r\n\tbm->setTextureThreshold(10);\r\n\tbm->setUniquenessRatio(uniquenessRatio);//uniquenessRatioҪԷֹƥ\r\n\tbm->setSpeckleWindowSize(100);\r\n\tbm->setSpeckleRange(32);\r\n\tbm->setDisp12MaxDiff(-1);\r\n\tMat disp, disp8;\r\n\tbm->compute(rectifyImageL, rectifyImageR, disp);//ͼΪҶͼ\r\n\tdisp.convertTo(disp8, CV_8U, 255 / ((numDisparities * 16 + 16)*16.));//ӲCV_16Sʽ\r\n\treprojectImageTo3D(disp, xyz, Q, true); //ʵʱReprojectTo3DX / W, Y / W, Z / WҪ16(ҲW16)ܵõȷάϢ\r\n\txyz = xyz * 16;\r\n\timshow(\"disparity\", disp8);\r\n}\r\n\r\n/*****ص*****/\r\nstatic void onMouse(int event, int x, int y, int, void*)\r\n{\r\n\tif (selectObject)\r\n\t{\r\n\t\tselection.x = MIN(x, origin.x);\r\n\t\tselection.y = MIN(y, origin.y);\r\n\t\tselection.width = std::abs(x - origin.x);\r\n\t\tselection.height = std::abs(y - origin.y);\r\n\t}\r\n\r\n\tswitch (event)\r\n\t{\r\n\tcase EVENT_LBUTTONDOWN: //ťµ¼\r\n\t\torigin = Point(x, y);\r\n\t\tselection = Rect(x, y, 0, 0);\r\n\t\tselectObject = true;\r\n\t\t//cout << origin << \"in world coordinate is: \" << xyz.at(origin) << endl;\r\n\t\tpoint3 = xyz.at(origin);\r\n\t\tpoint3[0];\r\n\t\t//cout << \"point3[0]:\" << point3[0] << \"point3[1]:\" << point3[1] << \"point3[2]:\" << point3[2]< 0 && selection.height > 0)\r\n\t\t\tbreak;\r\n\t}\r\n}\r\n\r\n\r\n/**********/\r\nint main()\r\n{\r\n\t/*\r\n\tУ\r\n\t*/\r\n\tRodrigues(rec, R); //Rodrigues任\r\n\tstereoRectify(cameraMatrixL, distCoeffL, cameraMatrixR, distCoeffR, imageSize, R, T, Rl, Rr, Pl, Pr, Q, CALIB_ZERO_DISPARITY,\r\n\t\t0, imageSize, &validROIL, &validROIR);\r\n\tinitUndistortRectifyMap(cameraMatrixL, distCoeffL, Rl, Pr, imageSize, CV_32FC1, mapLx, mapLy);\r\n\tinitUndistortRectifyMap(cameraMatrixR, distCoeffR, Rr, Pr, imageSize, CV_32FC1, mapRx, mapRy);\r\n\r\n\t/*\r\n\tȡͼƬ\r\n\t*/\r\n\r\n\tm_l_select = Rect(0, 0, 640, 480);\r\n\timg = imread(\"car.jpg\", IMREAD_COLOR);\r\n\t//imshow(\"Image\", img);\r\n\trgbImageL = img(m_l_select);\r\n\tcvtColor(rgbImageL, grayImageL, COLOR_BGR2GRAY);\r\n\r\n\tm_r_select = Rect(640, 0, 640, 480);\r\n\trgbImageR = img(m_r_select);\r\n\tcvtColor(rgbImageR, grayImageR, COLOR_BGR2GRAY);\r\n\r\n\t//imshow(\"ImageL\", rgbImageL);\r\n\t//imshow(\"ImageR\", rgbImageR);\r\n\r\n\t/*\r\n\tremap֮ͼѾ沢ж׼\r\n\t*/\r\n\tremap(grayImageL, rectifyImageL, mapLx, mapLy, INTER_LINEAR);\r\n\tremap(grayImageR, rectifyImageR, mapRx, mapRy, INTER_LINEAR);\r\n\r\n\t/*\r\n\tУʾ\r\n\t*/\r\n\tMat rgbRectifyImageL, rgbRectifyImageR;\r\n\tcvtColor(rectifyImageL, rgbRectifyImageL, COLOR_GRAY2BGR); //αɫͼ\r\n\tcvtColor(rectifyImageR, rgbRectifyImageR, COLOR_GRAY2BGR);\r\n\r\n\t//ʾ\r\n\t//rectangle(rgbRectifyImageL, validROIL, Scalar(0, 0, 255), 3, 8);\r\n\t//rectangle(rgbRectifyImageR, validROIR, Scalar(0, 0, 255), 3, 8);\r\n\t//imshow(\"ImageL After Rectify\", rgbRectifyImageL);\r\n\t//imshow(\"ImageR After Rectify\", rgbRectifyImageR);\r\n\r\n\t//ʾͬһͼ\r\n\tMat canvas;\r\n\tdouble sf;\r\n\tint w, h;\r\n\tsf = 600. / MAX(imageSize.width, imageSize.height);\r\n\tw = cvRound(imageSize.width * sf);\r\n\th = cvRound(imageSize.height * sf);\r\n\tcanvas.create(h, w * 2, CV_8UC3); //עͨ\r\n\r\n\t\t\t\t\t\t\t\t\t\t//ͼ񻭵\r\n\tMat canvasPart = canvas(Rect(w * 0, 0, w, h)); //õһ \r\n\tresize(rgbRectifyImageL, canvasPart, canvasPart.size(), 0, 0, INTER_AREA); //ͼŵcanvasPartһС \r\n\tRect vroiL(cvRound(validROIL.x*sf), cvRound(validROIL.y*sf), //ñȡ \r\n\t\tcvRound(validROIL.width*sf), cvRound(validROIL.height*sf));\r\n\t//rectangle(canvasPart, vroiL, Scalar(0, 0, 255), 3, 8); //һ \r\n\tcout << \"Painted ImageL\" << endl;\r\n\r\n\t//ͼ񻭵\r\n\tcanvasPart = canvas(Rect(w, 0, w, h)); //ûһ \r\n\tresize(rgbRectifyImageR, canvasPart, canvasPart.size(), 0, 0, INTER_LINEAR);\r\n\tRect vroiR(cvRound(validROIR.x * sf), cvRound(validROIR.y*sf),\r\n\t\tcvRound(validROIR.width * sf), cvRound(validROIR.height * sf));\r\n\t//rectangle(canvasPart, vroiR, Scalar(0, 0, 255), 3, 8);\r\n\tcout << \"Painted ImageR\" << endl;\r\n\r\n\t//϶Ӧ\r\n\tfor (int i = 0; i < canvas.rows; i += 16)\r\n\t\tline(canvas, Point(0, i), Point(canvas.cols, i), Scalar(0, 255, 0), 1, 8);\r\n\timshow(\"rectified\", canvas);\r\n\r\n\t/*\r\n\tƥ\r\n\t*/\r\n\tnamedWindow(\"disparity\", WINDOW_AUTOSIZE);\r\n\r\n\t/*************************οӻ**********************************************/\r\n\t// SAD Trackbar\r\n\t//createTrackbar(\"BlockSize:\\n\", \"disparity\", &blockSize, 8, stereo_match);\r\n\t// ӲΨһ԰ٷֱȴ Trackbar\r\n\t//createTrackbar(\"UniquenessRatio:\\n\", \"disparity\", &uniquenessRatio, 50, stereo_match);\r\n\t// Ӳ Trackbar\r\n\t//createTrackbar(\"NumDisparities:\\n\", \"disparity\", &numDisparities, 16, stereo_match);\r\n\t\r\n\r\n\t//ӦsetMouseCallback(, ص, صIJһȡ0)\r\n\tsetMouseCallback(\"disparity\", onMouse, 0);\r\n\tstereo_match(0, 0);\r\n\r\n\twaitKey();\r\n return 0;\r\n}\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n" }, { "path": "BM(Python)/BM.py", "content": "import cv2\r\nimport camera_configs\r\nimport math\r\nimport os\r\n# 引入函数库\r\nimport datetime as dt\r\n\r\nfloder = os.getcwd()\r\ncap = cv2.VideoCapture(0)\r\ncap.set(3, 2560)\r\ncap.set(4, 720) #打开并设置摄像头\r\n# 鼠标回调函数\r\ndef onmouse_pick_points(event, x, y, flags, param):\r\n if event == cv2.EVENT_LBUTTONDOWN:\r\n threeD = param\r\n print('\\n像素坐标 x = %d, y = %d' % (x, y))\r\n # print(\"世界坐标是：\", threeD[y][x][0], threeD[y][x][1], threeD[y][x][2], \"mm\")\r\n print(\"世界坐标xyz 是：\", threeD[y][x][0]/ 1000.0 , threeD[y][x][1]/ 1000.0 , threeD[y][x][2]/ 1000.0 , \"m\")\r\n\r\n distance = math.sqrt( threeD[y][x][0] **2 + threeD[y][x][1] **2 + threeD[y][x][2] **2 )\r\n distance = distance / 1000.0 # mm -> m\r\n print(\"距离是：\", distance, \"m\")\r\n\r\nWIN_NAME = 'Deep disp'\r\ncv2.namedWindow(WIN_NAME, cv2.WINDOW_AUTOSIZE)\r\n\r\nwhile True:\r\n ret, frame = cap.read()\r\n frame1 = frame[0:720, 0:1280]\r\n frame2 = frame[0:720, 1280:2560] #割开双目图像\r\n\r\n imgL = cv2.cvtColor(frame1, cv2.COLOR_BGR2GRAY) # 将BGR格式转换成灰度图片\r\n imgR = cv2.cvtColor(frame2, cv2.COLOR_BGR2GRAY)\r\n\r\n # cv2.remap 重映射，就是把一幅图像中某位置的像素放置到另一个图片指定位置的过程。\r\n # 依据MATLAB测量数据重建无畸变图片\r\n img1_rectified = cv2.remap(imgL, camera_configs.left_map1, camera_configs.left_map2, cv2.INTER_LINEAR)\r\n img2_rectified = cv2.remap(imgR, camera_configs.right_map1, camera_configs.right_map2, cv2.INTER_LINEAR)\r\n\r\n imageL = cv2.cvtColor(img1_rectified, cv2.COLOR_GRAY2BGR)\r\n imageR = cv2.cvtColor(img2_rectified, cv2.COLOR_GRAY2BGR)\r\n\r\n # BM\r\n numberOfDisparities = ((1280 // 8) + 15) & -16 # 640对应是分辨率的宽\r\n\r\n stereo = cv2.StereoBM_create(numDisparities=16, blockSize=9) #立体匹配\r\n stereo.setROI1(camera_configs.validPixROI1)\r\n stereo.setROI2(camera_configs.validPixROI2)\r\n stereo.setPreFilterCap(31)\r\n stereo.setBlockSize(15)\r\n stereo.setMinDisparity(0)\r\n stereo.setNumDisparities(numberOfDisparities)\r\n stereo.setTextureThreshold(10)\r\n stereo.setUniquenessRatio(15)\r\n stereo.setSpeckleWindowSize(100)\r\n stereo.setSpeckleRange(32)\r\n stereo.setDisp12MaxDiff(1)\r\n\r\n disparity = stereo.compute(img1_rectified, img2_rectified) # 计算视差\r\n\r\n disp = cv2.normalize(disparity, disparity, alpha=0, beta=255, norm_type=cv2.NORM_MINMAX, dtype=cv2.CV_8U) #归一化函数算法\r\n\r\n threeD = cv2.reprojectImageTo3D(disparity, camera_configs.Q, handleMissingValues=True) #计算三维坐标数据值\r\n threeD = threeD * 16\r\n\r\n # threeD[y][x] x:0~640; y:0~480; !!!!!!!!!!\r\n cv2.setMouseCallback(WIN_NAME, onmouse_pick_points, threeD)\r\n\r\n cv2.imshow(\"left\", frame1)\r\n # cv2.imshow(\"right\", frame2)\r\n # cv2.imshow(\"left_r\", imgL)\r\n # cv2.imshow(\"right_r\", imgR)\r\n cv2.imshow(WIN_NAME, disp) #显示深度图的双目画面\r\n\r\n key = cv2.waitKey(1)\r\n if key == ord(\"s\"):\r\n # 获取当前时间\r\n now_time = dt.datetime.now().strftime('%X')\r\n path = folder + \"\\img_\" + str(counter) + \".jpg\"\r\n cv2.imwrite(path, frame)\r\n print(\"snapshot saved into: \" + path)\r\n\r\n if key == ord(\"q\"):\r\n break\r\n\r\ncap.release()\r\ncv2.destroyAllWindows()" }, { "path": "BM(Python)/camera_configs.py", "content": "# author: young\r\nimport cv2\r\nimport numpy as np\r\n\r\n# 效果好\r\nleft_camera_matrix = np.array([[986.4572391,1.673607456,651.0717611],[0,1001.238398,535.8195077],[0.,0.,1.]])\r\n\r\n# left_distortion = np.array([[-0.154511565,0.325173292, 0.006934081,0.017466934, -0.340007548]])\r\nleft_distortion = np.array([[-0.154511565,0.325173292, 0.006934081,0.017466934, 0]])\r\n\r\nright_camera_matrix = np.array([[998.5848065,7.37746018,667.3698587],[0,1006.305891,528.9731771],[0.,0.,1.]])\r\n\r\n# right_distortion = np.array([[-0.192887524,0.706728768, 0.004233541,0.021340116,-1.175486913]])\r\nright_distortion = np.array([[-0.192887524,0.706728768, 0.004233541,0.021340116,0]])\r\n\r\nR = np.array([[0.999925137,-0.003616734,-0.01168927],\r\n [0.003742452,0.999935202,0.010751105],\r\n [0.011649629,-0.010794046,0.999873879]])\r\n\r\nT = np.array([-117.3364039,0.277054571,-3.7672413])\r\n\r\n# 角度很多但效果一般\r\n# right_camera_matrix = np.array([[1011.630992,6.392290621,667.5686089],\r\n# [ 0,1013.460245,503.4011875],\r\n# [0., 0,1.0000]])\r\n# right_distortion = np.array([[-0.078598405,0.181429846, 0.005991071,0.011485758,-0.216528642]])\r\n#\r\n# left_camera_matrix = np.array([[999.2148594,1.517083305,664.099101],[ 0.,1004.928519,509.320943,], [0., 0,1.0000]])\r\n# left_distortion = np.array([[-0.068650958,0.329526482,0.009413124,0.007593334, -0.762189196]])\r\n#\r\n# R = np.matrix([[ 0.999995654,-0.001219991,-0.002683778],[0.001249395,0.999938918,0.010981796],[ 0.002670216,-0.010985102,0.999936097],])\r\n# T = np.array([-115.3587822,-0.643409169,1.336821271])\r\n\r\n\r\n\r\n\r\n# 墙平移\r\n# left_camera_matrix = np.array([[1023.60598,2.050151356,602.5534506],[0,976.0768203,398.6863484],[0.,0.,1.]])\r\n#\r\n# # left_distortion = np.array([[-0.154511565,0.325173292, 0.006934081,0.017466934, -0.340007548]])\r\n# left_distortion = np.array([[-0.001241482,\t0.372245099, -0.02528585,\t0.00214508,-1.007572978]])\r\n#\r\n# right_camera_matrix = np.array([[1117.411713,-7.109583921,648.9929444],[0,1069.494628,404.4101094],[0.,0.,1.]])\r\n#\r\n# # right_distortion = np.array([[-0.192887524,0.706728768, 0.004233541,0.021340116,-1.175486913]])\r\n# right_distortion = np.array([[0.064401477,0.162144856,-0.021187394,\t0.019547213,-0.331058671]])\r\n#\r\n# R = np.array([[0.999965088,0.007987609,0.002453816], [-0.008017785,0.999889171,0.012544361],[-0.002353345,-0.012563598,0.999918306]])\r\n#\r\n# T = np.array([-181.8512309,\t-19.42425901,125.5877407])\r\n\r\n\r\nsize = (1280, 720) # open windows size\r\n# R1:左摄像机旋转矩阵, P1:左摄像机投影矩阵, Q:重投影矩阵\r\nR1, R2, P1, P2, Q, validPixROI1, validPixROI2 = cv2.stereoRectify(left_camera_matrix, left_distortion,\r\n right_camera_matrix, right_distortion, size, R, T)\r\n\r\n# 校正查找映射表,将原始图像和校正后的图像上的点一一对应起来\r\nleft_map1, left_map2 = cv2.initUndistortRectifyMap(left_camera_matrix, left_distortion, R1, P1, size, cv2.CV_16SC2)\r\nright_map1, right_map2 = cv2.initUndistortRectifyMap(right_camera_matrix, right_distortion, R2, P2, size, cv2.CV_16SC2)\r\n\r\nprint(Q)\r\n\r\nimport numpy as np\r\n\r\n\r\n####################仅仅是一个示例###################################\r\n\r\n\r\n# 双目相机参数\r\nclass stereoCamera(object):\r\n def __init__(self):\r\n # 左相机内参\r\n self.cam_matrix_left = left_camera_matrix\r\n # 右相机内参\r\n self.cam_matrix_right = right_camera_matrix\r\n\r\n # 左右相机畸变系数:[k1, k2, p1, p2, k3]\r\n self.distortion_l = left_distortion\r\n self.distortion_r = right_distortion\r\n\r\n # 旋转矩阵\r\n self.R = R\r\n\r\n # 平移矩阵\r\n self.T = T\r\n\r\n # 焦距\r\n self.focal_length = 859.367 # 默认值，一般取立体校正后的重投影矩阵Q中的 Q[2,3]\r\n\r\n # 基线距离\r\n self.baseline = 119.9578 # 单位：mm， 为平移向量的第一个参数（取绝对值）\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n" }, { "path": "Jeston nano_tensorrt/CMakeLists.txt", "content": "cmake_minimum_required(VERSION 2.6)\n\nproject(yolov5)\n\nadd_definitions(-std=c++11)\nadd_definitions(-DAPI_EXPORTS)\noption(CUDA_USE_STATIC_CUDA_RUNTIME OFF)\nset(CMAKE_CXX_STANDARD 11)\nset(CMAKE_BUILD_TYPE Debug)\n\nfind_package(CUDA REQUIRED)\n\nif(WIN32)\nenable_language(CUDA)\nendif(WIN32)\n\ninclude_directories(${PROJECT_SOURCE_DIR}/include)\n# include and link dirs of cuda and tensorrt, you need adapt them if yours are different\n# cuda\ninclude_directories(/usr/local/cuda/include)\nlink_directories(/usr/local/cuda/lib64)\n# tensorrt\ninclude_directories(/usr/include/x86_64-linux-gnu/)\nlink_directories(/usr/lib/x86_64-linux-gnu/)\n\nset(CMAKE_CXX_FLAGS \"${CMAKE_CXX_FLAGS} -std=c++11 -Wall -Ofast -g -Wfatal-errors -D_MWAITXINTRIN_H_INCLUDED\")\ncuda_add_library(myplugins SHARED yololayer.cu)\ntarget_link_libraries(myplugins nvinfer cudart)\n\nfind_package(OpenCV)\ninclude_directories(${OpenCV_INCLUDE_DIRS})\n\n#cuda_add_executable(yolov5 calibrator.cpp yolov5.cpp preprocess.cu)\ncuda_add_library(yolov5 SHARED ${PROJECT_SOURCE_DIR}/yolov5.cpp ${PROJECT_SOURCE_DIR}/yololayer.cu ${PROJECT_SOURCE_DIR}/yololayer.h ${PROJECT_SOURCE_DIR}/preprocess.cu)\n\ntarget_link_libraries(yolov5 nvinfer)\ntarget_link_libraries(yolov5 cudart)\ntarget_link_libraries(yolov5 myplugins)\ntarget_link_libraries(yolov5 ${OpenCV_LIBS})\n\nif(UNIX)\nadd_definitions(-O2 -pthread)\nendif(UNIX)\n\n\n" }, { "path": "Jeston nano_tensorrt/calibrator.cpp", "content": "#include \n#include \n#include \n#include \n#include \"calibrator.h\"\n#include \"cuda_utils.h\"\n#include \"utils.h\"\n\nInt8EntropyCalibrator2::Int8EntropyCalibrator2(int batchsize, int input_w, int input_h, const char* img_dir, const char* calib_table_name, const char* input_blob_name, bool read_cache)\n : batchsize_(batchsize)\n , input_w_(input_w)\n , input_h_(input_h)\n , img_idx_(0)\n , img_dir_(img_dir)\n , calib_table_name_(calib_table_name)\n , input_blob_name_(input_blob_name)\n , read_cache_(read_cache)\n{\n input_count_ = 3 * input_w * input_h * batchsize;\n CUDA_CHECK(cudaMalloc(&device_input_, input_count_ * sizeof(float)));\n read_files_in_dir(img_dir, img_files_);\n}\n\nInt8EntropyCalibrator2::~Int8EntropyCalibrator2()\n{\n CUDA_CHECK(cudaFree(device_input_));\n}\n\nint Int8EntropyCalibrator2::getBatchSize() const TRT_NOEXCEPT\n{\n return batchsize_;\n}\n\nbool Int8EntropyCalibrator2::getBatch(void* bindings[], const char* names[], int nbBindings) TRT_NOEXCEPT\n{\n if (img_idx_ + batchsize_ > (int)img_files_.size()) {\n return false;\n }\n\n std::vector input_imgs_;\n for (int i = img_idx_; i < img_idx_ + batchsize_; i++) {\n std::cout << img_files_[i] << \" \" << i << std::endl;\n cv::Mat temp = cv::imread(img_dir_ + img_files_[i]);\n if (temp.empty()){\n std::cerr << \"Fatal error: image cannot open!\" << std::endl;\n return false;\n }\n cv::Mat pr_img = preprocess_img(temp, input_w_, input_h_);\n input_imgs_.push_back(pr_img);\n }\n img_idx_ += batchsize_;\n cv::Mat blob = cv::dnn::blobFromImages(input_imgs_, 1.0 / 255.0, cv::Size(input_w_, input_h_), cv::Scalar(0, 0, 0), true, false);\n\n CUDA_CHECK(cudaMemcpy(device_input_, blob.ptr(0), input_count_ * sizeof(float), cudaMemcpyHostToDevice));\n assert(!strcmp(names[0], input_blob_name_));\n bindings[0] = device_input_;\n return true;\n}\n\nconst void* Int8EntropyCalibrator2::readCalibrationCache(size_t& length) TRT_NOEXCEPT\n{\n std::cout << \"reading calib cache: \" << calib_table_name_ << std::endl;\n calib_cache_.clear();\n std::ifstream input(calib_table_name_, std::ios::binary);\n input >> std::noskipws;\n if (read_cache_ && input.good())\n {\n std::copy(std::istream_iterator(input), std::istream_iterator(), std::back_inserter(calib_cache_));\n }\n length = calib_cache_.size();\n return length ? calib_cache_.data() : nullptr;\n}\n\nvoid Int8EntropyCalibrator2::writeCalibrationCache(const void* cache, size_t length) TRT_NOEXCEPT\n{\n std::cout << \"writing calib cache: \" << calib_table_name_ << \" size: \" << length << std::endl;\n std::ofstream output(calib_table_name_, std::ios::binary);\n output.write(reinterpret_cast(cache), length);\n}\n\n" }, { "path": "Jeston nano_tensorrt/calibrator.h", "content": "#ifndef ENTROPY_CALIBRATOR_H\n#define ENTROPY_CALIBRATOR_H\n\n#include \n#include \n#include \n#include \"macros.h\"\n\n//! \\class Int8EntropyCalibrator2\n//!\n//! \\brief Implements Entropy calibrator 2.\n//! CalibrationAlgoType is kENTROPY_CALIBRATION_2.\n//!\nclass Int8EntropyCalibrator2 : public nvinfer1::IInt8EntropyCalibrator2\n{\npublic:\n Int8EntropyCalibrator2(int batchsize, int input_w, int input_h, const char* img_dir, const char* calib_table_name, const char* input_blob_name, bool read_cache = true);\n\n virtual ~Int8EntropyCalibrator2();\n int getBatchSize() const TRT_NOEXCEPT override;\n bool getBatch(void* bindings[], const char* names[], int nbBindings) TRT_NOEXCEPT override;\n const void* readCalibrationCache(size_t& length) TRT_NOEXCEPT override;\n void writeCalibrationCache(const void* cache, size_t length) TRT_NOEXCEPT override;\n\nprivate:\n int batchsize_;\n int input_w_;\n int input_h_;\n int img_idx_;\n std::string img_dir_;\n std::vector img_files_;\n size_t input_count_;\n std::string calib_table_name_;\n const char* input_blob_name_;\n bool read_cache_;\n void* device_input_;\n std::vector calib_cache_;\n};\n\n#endif // ENTROPY_CALIBRATOR_H\n" }, { "path": "Jeston nano_tensorrt/common.hpp", "content": "#ifndef YOLOV5_COMMON_H_\n#define YOLOV5_COMMON_H_\n\n#include \n#include \n#include \n#include \n#include \n#include \"NvInfer.h\"\n#include \"yololayer.h\"\n\nusing namespace nvinfer1;\n\ncv::Rect get_rect(cv::Mat& img, float bbox[4]) {\n float l, r, t, b;\n float r_w = Yolo::INPUT_W / (img.cols * 1.0);\n float r_h = Yolo::INPUT_H / (img.rows * 1.0);\n if (r_h > r_w) {\n l = bbox[0] - bbox[2] / 2.f;\n r = bbox[0] + bbox[2] / 2.f;\n t = bbox[1] - bbox[3] / 2.f - (Yolo::INPUT_H - r_w * img.rows) / 2;\n b = bbox[1] + bbox[3] / 2.f - (Yolo::INPUT_H - r_w * img.rows) / 2;\n l = l / r_w;\n r = r / r_w;\n t = t / r_w;\n b = b / r_w;\n } else {\n l = bbox[0] - bbox[2] / 2.f - (Yolo::INPUT_W - r_h * img.cols) / 2;\n r = bbox[0] + bbox[2] / 2.f - (Yolo::INPUT_W - r_h * img.cols) / 2;\n t = bbox[1] - bbox[3] / 2.f;\n b = bbox[1] + bbox[3] / 2.f;\n l = l / r_h;\n r = r / r_h;\n t = t / r_h;\n b = b / r_h;\n }\n return cv::Rect(round(l), round(t), round(r - l), round(b - t));\n}\n\nfloat iou(float lbox[4], float rbox[4]) {\n float interBox[] = {\n (std::max)(lbox[0] - lbox[2] / 2.f , rbox[0] - rbox[2] / 2.f), //left\n (std::min)(lbox[0] + lbox[2] / 2.f , rbox[0] + rbox[2] / 2.f), //right\n (std::max)(lbox[1] - lbox[3] / 2.f , rbox[1] - rbox[3] / 2.f), //top\n (std::min)(lbox[1] + lbox[3] / 2.f , rbox[1] + rbox[3] / 2.f), //bottom\n };\n\n if (interBox[2] > interBox[3] || interBox[0] > interBox[1])\n return 0.0f;\n\n float interBoxS = (interBox[1] - interBox[0])*(interBox[3] - interBox[2]);\n return interBoxS / (lbox[2] * lbox[3] + rbox[2] * rbox[3] - interBoxS);\n}\n\nbool cmp(const Yolo::Detection& a, const Yolo::Detection& b) {\n return a.conf > b.conf;\n}\n\nvoid nms(std::vector& res, float *output, float conf_thresh, float nms_thresh = 0.5) {\n int det_size = sizeof(Yolo::Detection) / sizeof(float);\n std::map> m;\n for (int i = 0; i < output[0] && i < Yolo::MAX_OUTPUT_BBOX_COUNT; i++) {\n if (output[1 + det_size * i + 4] <= conf_thresh) continue;\n Yolo::Detection det;\n memcpy(&det, &output[1 + det_size * i], det_size * sizeof(float));\n if (m.count(det.class_id) == 0) m.emplace(det.class_id, std::vector());\n m[det.class_id].push_back(det);\n }\n for (auto it = m.begin(); it != m.end(); it++) {\n //std::cout << it->second[0].class_id << \" --- \" << std::endl;\n auto& dets = it->second;\n std::sort(dets.begin(), dets.end(), cmp);\n for (size_t m = 0; m < dets.size(); ++m) {\n auto& item = dets[m];\n res.push_back(item);\n for (size_t n = m + 1; n < dets.size(); ++n) {\n if (iou(item.bbox, dets[n].bbox) > nms_thresh) {\n dets.erase(dets.begin() + n);\n --n;\n }\n }\n }\n }\n}\n\n// TensorRT weight files have a simple space delimited format:\n// [type] [size] \nstd::map loadWeights(const std::string file) {\n std::cout << \"Loading weights: \" << file << std::endl;\n std::map weightMap;\n\n // Open weights file\n std::ifstream input(file);\n assert(input.is_open() && \"Unable to load weight file. please check if the .wts file path is right!!!!!!\");\n\n // Read number of weight blobs\n int32_t count;\n input >> count;\n assert(count > 0 && \"Invalid weight map file.\");\n\n while (count--)\n {\n Weights wt{ DataType::kFLOAT, nullptr, 0 };\n uint32_t size;\n\n // Read name and type of blob\n std::string name;\n input >> name >> std::dec >> size;\n wt.type = DataType::kFLOAT;\n\n // Load blob\n uint32_t* val = reinterpret_cast(malloc(sizeof(val) * size));\n for (uint32_t x = 0, y = size; x < y; ++x)\n {\n input >> std::hex >> val[x];\n }\n wt.values = val;\n\n wt.count = size;\n weightMap[name] = wt;\n }\n\n return weightMap;\n}\n\nIScaleLayer* addBatchNorm2d(INetworkDefinition *network, std::map& weightMap, ITensor& input, std::string lname, float eps) {\n float *gamma = (float*)weightMap[lname + \".weight\"].values;\n float *beta = (float*)weightMap[lname + \".bias\"].values;\n float *mean = (float*)weightMap[lname + \".running_mean\"].values;\n float *var = (float*)weightMap[lname + \".running_var\"].values;\n int len = weightMap[lname + \".running_var\"].count;\n\n float *scval = reinterpret_cast(malloc(sizeof(float) * len));\n for (int i = 0; i < len; i++) {\n scval[i] = gamma[i] / sqrt(var[i] + eps);\n }\n Weights scale{ DataType::kFLOAT, scval, len };\n\n float *shval = reinterpret_cast(malloc(sizeof(float) * len));\n for (int i = 0; i < len; i++) {\n shval[i] = beta[i] - mean[i] * gamma[i] / sqrt(var[i] + eps);\n }\n Weights shift{ DataType::kFLOAT, shval, len };\n\n float *pval = reinterpret_cast(malloc(sizeof(float) * len));\n for (int i = 0; i < len; i++) {\n pval[i] = 1.0;\n }\n Weights power{ DataType::kFLOAT, pval, len };\n\n weightMap[lname + \".scale\"] = scale;\n weightMap[lname + \".shift\"] = shift;\n weightMap[lname + \".power\"] = power;\n IScaleLayer* scale_1 = network->addScale(input, ScaleMode::kCHANNEL, shift, scale, power);\n assert(scale_1);\n return scale_1;\n}\n\n\n\nILayer* convBlock(INetworkDefinition *network, std::map& weightMap, ITensor& input, int outch, int ksize, int s, int g, std::string lname) {\n Weights emptywts{ DataType::kFLOAT, nullptr, 0 };\n int p = ksize / 3;\n IConvolutionLayer* conv1 = network->addConvolutionNd(input, outch, DimsHW{ ksize, ksize }, weightMap[lname + \".conv.weight\"], emptywts);\n assert(conv1);\n conv1->setStrideNd(DimsHW{ s, s });\n conv1->setPaddingNd(DimsHW{ p, p });\n conv1->setNbGroups(g);\n IScaleLayer* bn1 = addBatchNorm2d(network, weightMap, *conv1->getOutput(0), lname + \".bn\", 1e-3);\n\n // silu = x * sigmoid\n auto sig = network->addActivation(*bn1->getOutput(0), ActivationType::kSIGMOID);\n assert(sig);\n auto ew = network->addElementWise(*bn1->getOutput(0), *sig->getOutput(0), ElementWiseOperation::kPROD);\n assert(ew);\n return ew;\n}\n\nILayer* focus(INetworkDefinition *network, std::map& weightMap, ITensor& input, int inch, int outch, int ksize, std::string lname) {\n ISliceLayer *s1 = network->addSlice(input, Dims3{ 0, 0, 0 }, Dims3{ inch, Yolo::INPUT_H / 2, Yolo::INPUT_W / 2 }, Dims3{ 1, 2, 2 });\n ISliceLayer *s2 = network->addSlice(input, Dims3{ 0, 1, 0 }, Dims3{ inch, Yolo::INPUT_H / 2, Yolo::INPUT_W / 2 }, Dims3{ 1, 2, 2 });\n ISliceLayer *s3 = network->addSlice(input, Dims3{ 0, 0, 1 }, Dims3{ inch, Yolo::INPUT_H / 2, Yolo::INPUT_W / 2 }, Dims3{ 1, 2, 2 });\n ISliceLayer *s4 = network->addSlice(input, Dims3{ 0, 1, 1 }, Dims3{ inch, Yolo::INPUT_H / 2, Yolo::INPUT_W / 2 }, Dims3{ 1, 2, 2 });\n ITensor* inputTensors[] = { s1->getOutput(0), s2->getOutput(0), s3->getOutput(0), s4->getOutput(0) };\n auto cat = network->addConcatenation(inputTensors, 4);\n auto conv = convBlock(network, weightMap, *cat->getOutput(0), outch, ksize, 1, 1, lname + \".conv\");\n return conv;\n}\n\nILayer* bottleneck(INetworkDefinition *network, std::map& weightMap, ITensor& input, int c1, int c2, bool shortcut, int g, float e, std::string lname) {\n auto cv1 = convBlock(network, weightMap, input, (int)((float)c2 * e), 1, 1, 1, lname + \".cv1\");\n auto cv2 = convBlock(network, weightMap, *cv1->getOutput(0), c2, 3, 1, g, lname + \".cv2\");\n if (shortcut && c1 == c2) {\n auto ew = network->addElementWise(input, *cv2->getOutput(0), ElementWiseOperation::kSUM);\n return ew;\n }\n return cv2;\n}\n\nILayer* bottleneckCSP(INetworkDefinition *network, std::map& weightMap, ITensor& input, int c1, int c2, int n, bool shortcut, int g, float e, std::string lname) {\n Weights emptywts{ DataType::kFLOAT, nullptr, 0 };\n int c_ = (int)((float)c2 * e);\n auto cv1 = convBlock(network, weightMap, input, c_, 1, 1, 1, lname + \".cv1\");\n auto cv2 = network->addConvolutionNd(input, c_, DimsHW{ 1, 1 }, weightMap[lname + \".cv2.weight\"], emptywts);\n ITensor *y1 = cv1->getOutput(0);\n for (int i = 0; i < n; i++) {\n auto b = bottleneck(network, weightMap, *y1, c_, c_, shortcut, g, 1.0, lname + \".m.\" + std::to_string(i));\n y1 = b->getOutput(0);\n }\n auto cv3 = network->addConvolutionNd(*y1, c_, DimsHW{ 1, 1 }, weightMap[lname + \".cv3.weight\"], emptywts);\n\n ITensor* inputTensors[] = { cv3->getOutput(0), cv2->getOutput(0) };\n auto cat = network->addConcatenation(inputTensors, 2);\n\n IScaleLayer* bn = addBatchNorm2d(network, weightMap, *cat->getOutput(0), lname + \".bn\", 1e-4);\n auto lr = network->addActivation(*bn->getOutput(0), ActivationType::kLEAKY_RELU);\n lr->setAlpha(0.1);\n\n auto cv4 = convBlock(network, weightMap, *lr->getOutput(0), c2, 1, 1, 1, lname + \".cv4\");\n return cv4;\n}\n\nILayer* C3(INetworkDefinition *network, std::map& weightMap, ITensor& input, int c1, int c2, int n, bool shortcut, int g, float e, std::string lname) {\n int c_ = (int)((float)c2 * e);\n auto cv1 = convBlock(network, weightMap, input, c_, 1, 1, 1, lname + \".cv1\");\n auto cv2 = convBlock(network, weightMap, input, c_, 1, 1, 1, lname + \".cv2\");\n ITensor *y1 = cv1->getOutput(0);\n for (int i = 0; i < n; i++) {\n auto b = bottleneck(network, weightMap, *y1, c_, c_, shortcut, g, 1.0, lname + \".m.\" + std::to_string(i));\n y1 = b->getOutput(0);\n }\n\n ITensor* inputTensors[] = { y1, cv2->getOutput(0) };\n auto cat = network->addConcatenation(inputTensors, 2);\n\n auto cv3 = convBlock(network, weightMap, *cat->getOutput(0), c2, 1, 1, 1, lname + \".cv3\");\n return cv3;\n}\n\nILayer* SPP(INetworkDefinition *network, std::map& weightMap, ITensor& input, int c1, int c2, int k1, int k2, int k3, std::string lname) {\n int c_ = c1 / 2;\n auto cv1 = convBlock(network, weightMap, input, c_, 1, 1, 1, lname + \".cv1\");\n\n auto pool1 = network->addPoolingNd(*cv1->getOutput(0), PoolingType::kMAX, DimsHW{ k1, k1 });\n pool1->setPaddingNd(DimsHW{ k1 / 2, k1 / 2 });\n pool1->setStrideNd(DimsHW{ 1, 1 });\n auto pool2 = network->addPoolingNd(*cv1->getOutput(0), PoolingType::kMAX, DimsHW{ k2, k2 });\n pool2->setPaddingNd(DimsHW{ k2 / 2, k2 / 2 });\n pool2->setStrideNd(DimsHW{ 1, 1 });\n auto pool3 = network->addPoolingNd(*cv1->getOutput(0), PoolingType::kMAX, DimsHW{ k3, k3 });\n pool3->setPaddingNd(DimsHW{ k3 / 2, k3 / 2 });\n pool3->setStrideNd(DimsHW{ 1, 1 });\n\n ITensor* inputTensors[] = { cv1->getOutput(0), pool1->getOutput(0), pool2->getOutput(0), pool3->getOutput(0) };\n auto cat = network->addConcatenation(inputTensors, 4);\n\n auto cv2 = convBlock(network, weightMap, *cat->getOutput(0), c2, 1, 1, 1, lname + \".cv2\");\n return cv2;\n}\n\nILayer* SPPF(INetworkDefinition *network, std::map& weightMap, ITensor& input, int c1, int c2, int k, std::string lname) {\n int c_ = c1 / 2;\n auto cv1 = convBlock(network, weightMap, input, c_, 1, 1, 1, lname + \".cv1\");\n\n auto pool1 = network->addPoolingNd(*cv1->getOutput(0), PoolingType::kMAX, DimsHW{ k, k });\n pool1->setPaddingNd(DimsHW{ k / 2, k / 2 });\n pool1->setStrideNd(DimsHW{ 1, 1 });\n auto pool2 = network->addPoolingNd(*pool1->getOutput(0), PoolingType::kMAX, DimsHW{ k, k });\n pool2->setPaddingNd(DimsHW{ k / 2, k / 2 });\n pool2->setStrideNd(DimsHW{ 1, 1 });\n auto pool3 = network->addPoolingNd(*pool2->getOutput(0), PoolingType::kMAX, DimsHW{ k, k });\n pool3->setPaddingNd(DimsHW{ k / 2, k / 2 });\n pool3->setStrideNd(DimsHW{ 1, 1 });\n ITensor* inputTensors[] = { cv1->getOutput(0), pool1->getOutput(0), pool2->getOutput(0), pool3->getOutput(0) };\n auto cat = network->addConcatenation(inputTensors, 4);\n auto cv2 = convBlock(network, weightMap, *cat->getOutput(0), c2, 1, 1, 1, lname + \".cv2\");\n return cv2;\n}\n\nstd::vector> getAnchors(std::map& weightMap, std::string lname) {\n std::vector> anchors;\n Weights wts = weightMap[lname + \".anchor_grid\"];\n int anchor_len = Yolo::CHECK_COUNT * 2;\n for (int i = 0; i < wts.count / anchor_len; i++) {\n auto *p = (const float*)wts.values + i * anchor_len;\n std::vector anchor(p, p + anchor_len);\n anchors.push_back(anchor);\n }\n return anchors;\n}\n\nIPluginV2Layer* addYoLoLayer(INetworkDefinition *network, std::map& weightMap, std::string lname, std::vector dets) {\n auto creator = getPluginRegistry()->getPluginCreator(\"YoloLayer_TRT\", \"1\");\n auto anchors = getAnchors(weightMap, lname);\n PluginField plugin_fields[2];\n int netinfo[4] = {Yolo::CLASS_NUM, Yolo::INPUT_W, Yolo::INPUT_H, Yolo::MAX_OUTPUT_BBOX_COUNT};\n plugin_fields[0].data = netinfo;\n plugin_fields[0].length = 4;\n plugin_fields[0].name = \"netinfo\";\n plugin_fields[0].type = PluginFieldType::kFLOAT32;\n int scale = 8;\n std::vector kernels;\n for (size_t i = 0; i < anchors.size(); i++) {\n Yolo::YoloKernel kernel;\n kernel.width = Yolo::INPUT_W / scale;\n kernel.height = Yolo::INPUT_H / scale;\n memcpy(kernel.anchors, &anchors[i][0], anchors[i].size() * sizeof(float));\n kernels.push_back(kernel);\n scale *= 2;\n }\n plugin_fields[1].data = &kernels[0];\n plugin_fields[1].length = kernels.size();\n plugin_fields[1].name = \"kernels\";\n plugin_fields[1].type = PluginFieldType::kFLOAT32;\n PluginFieldCollection plugin_data;\n plugin_data.nbFields = 2;\n plugin_data.fields = plugin_fields;\n IPluginV2 *plugin_obj = creator->createPlugin(\"yololayer\", &plugin_data);\n std::vector input_tensors;\n for (auto det: dets) {\n input_tensors.push_back(det->getOutput(0));\n }\n auto yolo = network->addPluginV2(&input_tensors[0], input_tensors.size(), *plugin_obj);\n return yolo;\n}\n#endif\n\n" }, { "path": "Jeston nano_tensorrt/cuda_utils.h", "content": "#ifndef TRTX_CUDA_UTILS_H_\n#define TRTX_CUDA_UTILS_H_\n\n#include \n\n#ifndef CUDA_CHECK\n#define CUDA_CHECK(callstr)\\\n {\\\n cudaError_t error_code = callstr;\\\n if (error_code != cudaSuccess) {\\\n std::cerr << \"CUDA error \" << error_code << \" at \" << __FILE__ << \":\" << __LINE__;\\\n assert(0);\\\n }\\\n }\n#endif // CUDA_CHECK\n\n#endif // TRTX_CUDA_UTILS_H_\n\n" }, { "path": "Jeston nano_tensorrt/gen_wts.py", "content": "import sys\nimport argparse\nimport os\nimport struct\nimport torch\nfrom utils.torch_utils import select_device\n\n\ndef parse_args():\n parser = argparse.ArgumentParser(description='Convert .pt file to .wts')\n parser.add_argument('-w', '--weights', required=True, help='Input weights (.pt) file path (required)')\n parser.add_argument('-o', '--output', help='Output (.wts) file path (optional)')\n args = parser.parse_args()\n if not os.path.isfile(args.weights):\n raise SystemExit('Invalid input file')\n if not args.output:\n args.output = os.path.splitext(args.weights)[0] + '.wts'\n elif os.path.isdir(args.output):\n args.output = os.path.join(\n args.output,\n os.path.splitext(os.path.basename(args.weights))[0] + '.wts')\n return args.weights, args.output\n\n\npt_file, wts_file = parse_args()\n\n# Initialize\ndevice = select_device('cpu')\n# Load model\nmodel = torch.load(pt_file, map_location=device) # load to FP32\nmodel = model['ema' if model.get('ema') else 'model'].float()\n\n# update anchor_grid info\nanchor_grid = model.model[-1].anchors * model.model[-1].stride[...,None,None]\n# model.model[-1].anchor_grid = anchor_grid\ndelattr(model.model[-1], 'anchor_grid') # model.model[-1] is detect layer\nmodel.model[-1].register_buffer(\"anchor_grid\",anchor_grid) #The parameters are saved in the OrderDict through the \"register_buffer\" method, and then saved to the weight.\n\nmodel.to(device).eval()\n\nwith open(wts_file, 'w') as f:\n f.write('{}\\n'.format(len(model.state_dict().keys())))\n for k, v in model.state_dict().items():\n vr = v.reshape(-1).cpu().numpy()\n f.write('{} {} '.format(k, len(vr)))\n for vv in vr:\n f.write(' ')\n f.write(struct.pack('>f' ,float(vv)).hex())\n f.write('\\n')\n" }, { "path": "Jeston nano_tensorrt/logging.h", "content": "/*\n * Copyright (c) 2019, NVIDIA CORPORATION. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#ifndef TENSORRT_LOGGING_H\n#define TENSORRT_LOGGING_H\n\n#include \"NvInferRuntimeCommon.h\"\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \"macros.h\"\n\nusing Severity = nvinfer1::ILogger::Severity;\n\nclass LogStreamConsumerBuffer : public std::stringbuf\n{\npublic:\n LogStreamConsumerBuffer(std::ostream& stream, const std::string& prefix, bool shouldLog)\n : mOutput(stream)\n , mPrefix(prefix)\n , mShouldLog(shouldLog)\n {\n }\n\n LogStreamConsumerBuffer(LogStreamConsumerBuffer&& other)\n : mOutput(other.mOutput)\n {\n }\n\n ~LogStreamConsumerBuffer()\n {\n // std::streambuf::pbase() gives a pointer to the beginning of the buffered part of the output sequence\n // std::streambuf::pptr() gives a pointer to the current position of the output sequence\n // if the pointer to the beginning is not equal to the pointer to the current position,\n // call putOutput() to log the output to the stream\n if (pbase() != pptr())\n {\n putOutput();\n }\n }\n\n // synchronizes the stream buffer and returns 0 on success\n // synchronizing the stream buffer consists of inserting the buffer contents into the stream,\n // resetting the buffer and flushing the stream\n virtual int sync()\n {\n putOutput();\n return 0;\n }\n\n void putOutput()\n {\n if (mShouldLog)\n {\n // prepend timestamp\n std::time_t timestamp = std::time(nullptr);\n tm* tm_local = std::localtime(×tamp);\n std::cout << \"[\";\n std::cout << std::setw(2) << std::setfill('0') << 1 + tm_local->tm_mon << \"/\";\n std::cout << std::setw(2) << std::setfill('0') << tm_local->tm_mday << \"/\";\n std::cout << std::setw(4) << std::setfill('0') << 1900 + tm_local->tm_year << \"-\";\n std::cout << std::setw(2) << std::setfill('0') << tm_local->tm_hour << \":\";\n std::cout << std::setw(2) << std::setfill('0') << tm_local->tm_min << \":\";\n std::cout << std::setw(2) << std::setfill('0') << tm_local->tm_sec << \"] \";\n // std::stringbuf::str() gets the string contents of the buffer\n // insert the buffer contents pre-appended by the appropriate prefix into the stream\n mOutput << mPrefix << str();\n // set the buffer to empty\n str(\"\");\n // flush the stream\n mOutput.flush();\n }\n }\n\n void setShouldLog(bool shouldLog)\n {\n mShouldLog = shouldLog;\n }\n\nprivate:\n std::ostream& mOutput;\n std::string mPrefix;\n bool mShouldLog;\n};\n\n//!\n//! \\class LogStreamConsumerBase\n//! \\brief Convenience object used to initialize LogStreamConsumerBuffer before std::ostream in LogStreamConsumer\n//!\nclass LogStreamConsumerBase\n{\npublic:\n LogStreamConsumerBase(std::ostream& stream, const std::string& prefix, bool shouldLog)\n : mBuffer(stream, prefix, shouldLog)\n {\n }\n\nprotected:\n LogStreamConsumerBuffer mBuffer;\n};\n\n//!\n//! \\class LogStreamConsumer\n//! \\brief Convenience object used to facilitate use of C++ stream syntax when logging messages.\n//! Order of base classes is LogStreamConsumerBase and then std::ostream.\n//! This is because the LogStreamConsumerBase class is used to initialize the LogStreamConsumerBuffer member field\n//! in LogStreamConsumer and then the address of the buffer is passed to std::ostream.\n//! This is necessary to prevent the address of an uninitialized buffer from being passed to std::ostream.\n//! Please do not change the order of the parent classes.\n//!\nclass LogStreamConsumer : protected LogStreamConsumerBase, public std::ostream\n{\npublic:\n //! \\brief Creates a LogStreamConsumer which logs messages with level severity.\n //! Reportable severity determines if the messages are severe enough to be logged.\n LogStreamConsumer(Severity reportableSeverity, Severity severity)\n : LogStreamConsumerBase(severityOstream(severity), severityPrefix(severity), severity <= reportableSeverity)\n , std::ostream(&mBuffer) // links the stream buffer with the stream\n , mShouldLog(severity <= reportableSeverity)\n , mSeverity(severity)\n {\n }\n\n LogStreamConsumer(LogStreamConsumer&& other)\n : LogStreamConsumerBase(severityOstream(other.mSeverity), severityPrefix(other.mSeverity), other.mShouldLog)\n , std::ostream(&mBuffer) // links the stream buffer with the stream\n , mShouldLog(other.mShouldLog)\n , mSeverity(other.mSeverity)\n {\n }\n\n void setReportableSeverity(Severity reportableSeverity)\n {\n mShouldLog = mSeverity <= reportableSeverity;\n mBuffer.setShouldLog(mShouldLog);\n }\n\nprivate:\n static std::ostream& severityOstream(Severity severity)\n {\n return severity >= Severity::kINFO ? std::cout : std::cerr;\n }\n\n static std::string severityPrefix(Severity severity)\n {\n switch (severity)\n {\n case Severity::kINTERNAL_ERROR: return \"[F] \";\n case Severity::kERROR: return \"[E] \";\n case Severity::kWARNING: return \"[W] \";\n case Severity::kINFO: return \"[I] \";\n case Severity::kVERBOSE: return \"[V] \";\n default: assert(0); return \"\";\n }\n }\n\n bool mShouldLog;\n Severity mSeverity;\n};\n\n//! \\class Logger\n//!\n//! \\brief Class which manages logging of TensorRT tools and samples\n//!\n//! \\details This class provides a common interface for TensorRT tools and samples to log information to the console,\n//! and supports logging two types of messages:\n//!\n//! - Debugging messages with an associated severity (info, warning, error, or internal error/fatal)\n//! - Test pass/fail messages\n//!\n//! The advantage of having all samples use this class for logging as opposed to emitting directly to stdout/stderr is\n//! that the logic for controlling the verbosity and formatting of sample output is centralized in one location.\n//!\n//! In the future, this class could be extended to support dumping test results to a file in some standard format\n//! (for example, JUnit XML), and providing additional metadata (e.g. timing the duration of a test run).\n//!\n//! TODO: For backwards compatibility with existing samples, this class inherits directly from the nvinfer1::ILogger\n//! interface, which is problematic since there isn't a clean separation between messages coming from the TensorRT\n//! library and messages coming from the sample.\n//!\n//! In the future (once all samples are updated to use Logger::getTRTLogger() to access the ILogger) we can refactor the\n//! class to eliminate the inheritance and instead make the nvinfer1::ILogger implementation a member of the Logger\n//! object.\n\nclass Logger : public nvinfer1::ILogger\n{\npublic:\n Logger(Severity severity = Severity::kWARNING)\n : mReportableSeverity(severity)\n {\n }\n\n //!\n //! \\enum TestResult\n //! \\brief Represents the state of a given test\n //!\n enum class TestResult\n {\n kRUNNING, //!< The test is running\n kPASSED, //!< The test passed\n kFAILED, //!< The test failed\n kWAIVED //!< The test was waived\n };\n\n //!\n //! \\brief Forward-compatible method for retrieving the nvinfer::ILogger associated with this Logger\n //! \\return The nvinfer1::ILogger associated with this Logger\n //!\n //! TODO Once all samples are updated to use this method to register the logger with TensorRT,\n //! we can eliminate the inheritance of Logger from ILogger\n //!\n nvinfer1::ILogger& getTRTLogger()\n {\n return *this;\n }\n\n //!\n //! \\brief Implementation of the nvinfer1::ILogger::log() virtual method\n //!\n //! Note samples should not be calling this function directly; it will eventually go away once we eliminate the\n //! inheritance from nvinfer1::ILogger\n //!\n void log(Severity severity, const char* msg) TRT_NOEXCEPT override \n {\n LogStreamConsumer(mReportableSeverity, severity) << \"[TRT] \" << std::string(msg) << std::endl;\n }\n\n //!\n //! \\brief Method for controlling the verbosity of logging output\n //!\n //! \\param severity The logger will only emit messages that have severity of this level or higher.\n //!\n void setReportableSeverity(Severity severity)\n {\n mReportableSeverity = severity;\n }\n\n //!\n //! \\brief Opaque handle that holds logging information for a particular test\n //!\n //! This object is an opaque handle to information used by the Logger to print test results.\n //! The sample must call Logger::defineTest() in order to obtain a TestAtom that can be used\n //! with Logger::reportTest{Start,End}().\n //!\n class TestAtom\n {\n public:\n TestAtom(TestAtom&&) = default;\n\n private:\n friend class Logger;\n\n TestAtom(bool started, const std::string& name, const std::string& cmdline)\n : mStarted(started)\n , mName(name)\n , mCmdline(cmdline)\n {\n }\n\n bool mStarted;\n std::string mName;\n std::string mCmdline;\n };\n\n //!\n //! \\brief Define a test for logging\n //!\n //! \\param[in] name The name of the test. This should be a string starting with\n //! \"TensorRT\" and containing dot-separated strings containing\n //! the characters [A-Za-z0-9_].\n //! For example, \"TensorRT.sample_googlenet\"\n //! \\param[in] cmdline The command line used to reproduce the test\n //\n //! \\return a TestAtom that can be used in Logger::reportTest{Start,End}().\n //!\n static TestAtom defineTest(const std::string& name, const std::string& cmdline)\n {\n return TestAtom(false, name, cmdline);\n }\n\n //!\n //! \\brief A convenience overloaded version of defineTest() that accepts an array of command-line arguments\n //! as input\n //!\n //! \\param[in] name The name of the test\n //! \\param[in] argc The number of command-line arguments\n //! \\param[in] argv The array of command-line arguments (given as C strings)\n //!\n //! \\return a TestAtom that can be used in Logger::reportTest{Start,End}().\n static TestAtom defineTest(const std::string& name, int argc, char const* const* argv)\n {\n auto cmdline = genCmdlineString(argc, argv);\n return defineTest(name, cmdline);\n }\n\n //!\n //! \\brief Report that a test has started.\n //!\n //! \\pre reportTestStart() has not been called yet for the given testAtom\n //!\n //! \\param[in] testAtom The handle to the test that has started\n //!\n static void reportTestStart(TestAtom& testAtom)\n {\n reportTestResult(testAtom, TestResult::kRUNNING);\n assert(!testAtom.mStarted);\n testAtom.mStarted = true;\n }\n\n //!\n //! \\brief Report that a test has ended.\n //!\n //! \\pre reportTestStart() has been called for the given testAtom\n //!\n //! \\param[in] testAtom The handle to the test that has ended\n //! \\param[in] result The result of the test. Should be one of TestResult::kPASSED,\n //! TestResult::kFAILED, TestResult::kWAIVED\n //!\n static void reportTestEnd(const TestAtom& testAtom, TestResult result)\n {\n assert(result != TestResult::kRUNNING);\n assert(testAtom.mStarted);\n reportTestResult(testAtom, result);\n }\n\n static int reportPass(const TestAtom& testAtom)\n {\n reportTestEnd(testAtom, TestResult::kPASSED);\n return EXIT_SUCCESS;\n }\n\n static int reportFail(const TestAtom& testAtom)\n {\n reportTestEnd(testAtom, TestResult::kFAILED);\n return EXIT_FAILURE;\n }\n\n static int reportWaive(const TestAtom& testAtom)\n {\n reportTestEnd(testAtom, TestResult::kWAIVED);\n return EXIT_SUCCESS;\n }\n\n static int reportTest(const TestAtom& testAtom, bool pass)\n {\n return pass ? reportPass(testAtom) : reportFail(testAtom);\n }\n\n Severity getReportableSeverity() const\n {\n return mReportableSeverity;\n }\n\nprivate:\n //!\n //! \\brief returns an appropriate string for prefixing a log message with the given severity\n //!\n static const char* severityPrefix(Severity severity)\n {\n switch (severity)\n {\n case Severity::kINTERNAL_ERROR: return \"[F] \";\n case Severity::kERROR: return \"[E] \";\n case Severity::kWARNING: return \"[W] \";\n case Severity::kINFO: return \"[I] \";\n case Severity::kVERBOSE: return \"[V] \";\n default: assert(0); return \"\";\n }\n }\n\n //!\n //! \\brief returns an appropriate string for prefixing a test result message with the given result\n //!\n static const char* testResultString(TestResult result)\n {\n switch (result)\n {\n case TestResult::kRUNNING: return \"RUNNING\";\n case TestResult::kPASSED: return \"PASSED\";\n case TestResult::kFAILED: return \"FAILED\";\n case TestResult::kWAIVED: return \"WAIVED\";\n default: assert(0); return \"\";\n }\n }\n\n //!\n //! \\brief returns an appropriate output stream (cout or cerr) to use with the given severity\n //!\n static std::ostream& severityOstream(Severity severity)\n {\n return severity >= Severity::kINFO ? std::cout : std::cerr;\n }\n\n //!\n //! \\brief method that implements logging test results\n //!\n static void reportTestResult(const TestAtom& testAtom, TestResult result)\n {\n severityOstream(Severity::kINFO) << \"&&&& \" << testResultString(result) << \" \" << testAtom.mName << \" # \"\n << testAtom.mCmdline << std::endl;\n }\n\n //!\n //! \\brief generate a command line string from the given (argc, argv) values\n //!\n static std::string genCmdlineString(int argc, char const* const* argv)\n {\n std::stringstream ss;\n for (int i = 0; i < argc; i++)\n {\n if (i > 0)\n ss << \" \";\n ss << argv[i];\n }\n return ss.str();\n }\n\n Severity mReportableSeverity;\n};\n\nnamespace\n{\n\n//!\n//! \\brief produces a LogStreamConsumer object that can be used to log messages of severity kVERBOSE\n//!\n//! Example usage:\n//!\n//! LOG_VERBOSE(logger) << \"hello world\" << std::endl;\n//!\ninline LogStreamConsumer LOG_VERBOSE(const Logger& logger)\n{\n return LogStreamConsumer(logger.getReportableSeverity(), Severity::kVERBOSE);\n}\n\n//!\n//! \\brief produces a LogStreamConsumer object that can be used to log messages of severity kINFO\n//!\n//! Example usage:\n//!\n//! LOG_INFO(logger) << \"hello world\" << std::endl;\n//!\ninline LogStreamConsumer LOG_INFO(const Logger& logger)\n{\n return LogStreamConsumer(logger.getReportableSeverity(), Severity::kINFO);\n}\n\n//!\n//! \\brief produces a LogStreamConsumer object that can be used to log messages of severity kWARNING\n//!\n//! Example usage:\n//!\n//! LOG_WARN(logger) << \"hello world\" << std::endl;\n//!\ninline LogStreamConsumer LOG_WARN(const Logger& logger)\n{\n return LogStreamConsumer(logger.getReportableSeverity(), Severity::kWARNING);\n}\n\n//!\n//! \\brief produces a LogStreamConsumer object that can be used to log messages of severity kERROR\n//!\n//! Example usage:\n//!\n//! LOG_ERROR(logger) << \"hello world\" << std::endl;\n//!\ninline LogStreamConsumer LOG_ERROR(const Logger& logger)\n{\n return LogStreamConsumer(logger.getReportableSeverity(), Severity::kERROR);\n}\n\n//!\n//! \\brief produces a LogStreamConsumer object that can be used to log messages of severity kINTERNAL_ERROR\n// (\"fatal\" severity)\n//!\n//! Example usage:\n//!\n//! LOG_FATAL(logger) << \"hello world\" << std::endl;\n//!\ninline LogStreamConsumer LOG_FATAL(const Logger& logger)\n{\n return LogStreamConsumer(logger.getReportableSeverity(), Severity::kINTERNAL_ERROR);\n}\n\n} // anonymous namespace\n\n#endif // TENSORRT_LOGGING_H\n" }, { "path": "Jeston nano_tensorrt/macros.h", "content": "#ifndef __MACROS_H\n#define __MACROS_H\n\n#ifdef API_EXPORTS\n#if defined(_MSC_VER)\n#define API __declspec(dllexport)\n#else\n#define API __attribute__((visibility(\"default\")))\n#endif\n#else\n\n#if defined(_MSC_VER)\n#define API __declspec(dllimport)\n#else\n#define API\n#endif\n#endif // API_EXPORTS\n\n#if NV_TENSORRT_MAJOR >= 8\n#define TRT_NOEXCEPT noexcept\n#define TRT_CONST_ENQUEUE const\n#else\n#define TRT_NOEXCEPT\n#define TRT_CONST_ENQUEUE\n#endif\n\n#endif // __MACROS_H\n" }, { "path": "Jeston nano_tensorrt/preprocess.cu", "content": "#include \"preprocess.h\"\n#include \n\n__global__ void warpaffine_kernel( \n uint8_t* src, int src_line_size, int src_width, \n int src_height, float* dst, int dst_width, \n int dst_height, uint8_t const_value_st,\n AffineMatrix d2s, int edge) {\n int position = blockDim.x * blockIdx.x + threadIdx.x;\n if (position >= edge) return;\n\n float m_x1 = d2s.value[0];\n float m_y1 = d2s.value[1];\n float m_z1 = d2s.value[2];\n float m_x2 = d2s.value[3];\n float m_y2 = d2s.value[4];\n float m_z2 = d2s.value[5];\n\n int dx = position % dst_width;\n int dy = position / dst_width;\n float src_x = m_x1 * dx + m_y1 * dy + m_z1 + 0.5f;\n float src_y = m_x2 * dx + m_y2 * dy + m_z2 + 0.5f;\n float c0, c1, c2;\n\n if (src_x <= -1 || src_x >= src_width || src_y <= -1 || src_y >= src_height) {\n // out of range\n c0 = const_value_st;\n c1 = const_value_st;\n c2 = const_value_st;\n } else {\n int y_low = floorf(src_y);\n int x_low = floorf(src_x);\n int y_high = y_low + 1;\n int x_high = x_low + 1;\n\n uint8_t const_value[] = {const_value_st, const_value_st, const_value_st};\n float ly = src_y - y_low;\n float lx = src_x - x_low;\n float hy = 1 - ly;\n float hx = 1 - lx;\n float w1 = hy * hx, w2 = hy * lx, w3 = ly * hx, w4 = ly * lx;\n uint8_t* v1 = const_value;\n uint8_t* v2 = const_value;\n uint8_t* v3 = const_value;\n uint8_t* v4 = const_value;\n\n if (y_low >= 0) {\n if (x_low >= 0)\n v1 = src + y_low * src_line_size + x_low * 3;\n\n if (x_high < src_width)\n v2 = src + y_low * src_line_size + x_high * 3;\n }\n\n if (y_high < src_height) {\n if (x_low >= 0)\n v3 = src + y_high * src_line_size + x_low * 3;\n\n if (x_high < src_width)\n v4 = src + y_high * src_line_size + x_high * 3;\n }\n\n c0 = w1 * v1[0] + w2 * v2[0] + w3 * v3[0] + w4 * v4[0];\n c1 = w1 * v1[1] + w2 * v2[1] + w3 * v3[1] + w4 * v4[1];\n c2 = w1 * v1[2] + w2 * v2[2] + w3 * v3[2] + w4 * v4[2];\n }\n\n //bgr to rgb \n float t = c2;\n c2 = c0;\n c0 = t;\n\n //normalization\n c0 = c0 / 255.0f;\n c1 = c1 / 255.0f;\n c2 = c2 / 255.0f;\n\n //rgbrgbrgb to rrrgggbbb\n int area = dst_width * dst_height;\n float* pdst_c0 = dst + dy * dst_width + dx;\n float* pdst_c1 = pdst_c0 + area;\n float* pdst_c2 = pdst_c1 + area;\n *pdst_c0 = c0;\n *pdst_c1 = c1;\n *pdst_c2 = c2;\n}\n\nvoid preprocess_kernel_img(\n uint8_t* src, int src_width, int src_height,\n float* dst, int dst_width, int dst_height,\n cudaStream_t stream) {\n AffineMatrix s2d,d2s;\n float scale = std::min(dst_height / (float)src_height, dst_width / (float)src_width);\n\n s2d.value[0] = scale;\n s2d.value[1] = 0;\n s2d.value[2] = -scale * src_width * 0.5 + dst_width * 0.5;\n s2d.value[3] = 0;\n s2d.value[4] = scale;\n s2d.value[5] = -scale * src_height * 0.5 + dst_height * 0.5;\n\n cv::Mat m2x3_s2d(2, 3, CV_32F, s2d.value);\n cv::Mat m2x3_d2s(2, 3, CV_32F, d2s.value);\n cv::invertAffineTransform(m2x3_s2d, m2x3_d2s);\n\n memcpy(d2s.value, m2x3_d2s.ptr(0), sizeof(d2s.value));\n\n int jobs = dst_height * dst_width;\n int threads = 256;\n int blocks = ceil(jobs / (float)threads);\n warpaffine_kernel<<>>(\n src, src_width*3, src_width,\n src_height, dst, dst_width,\n dst_height, 128, d2s, jobs);\n\n}\n" }, { "path": "Jeston nano_tensorrt/preprocess.h", "content": "#ifndef __PREPROCESS_H\n#define __PREPROCESS_H\n\n#include \n#include \n\n\nstruct AffineMatrix{\n float value[6];\n};\n\n\nvoid preprocess_kernel_img(uint8_t* src, int src_width, int src_height,\n float* dst, int dst_width, int dst_height,\n cudaStream_t stream);\n#endif // __PREPROCESS_H\n" }, { "path": "Jeston nano_tensorrt/samples", "content": "../yolov3-spp/samples/" }, { "path": "Jeston nano_tensorrt/utils.h", "content": "#ifndef TRTX_YOLOV5_UTILS_H_\n#define TRTX_YOLOV5_UTILS_H_\n\n#include \n#include \n\nstatic inline cv::Mat preprocess_img(cv::Mat& img, int input_w, int input_h) {\n int w, h, x, y;\n float r_w = input_w / (img.cols*1.0);\n float r_h = input_h / (img.rows*1.0);\n if (r_h > r_w) {\n w = input_w;\n h = r_w * img.rows;\n x = 0;\n y = (input_h - h) / 2;\n } else {\n w = r_h * img.cols;\n h = input_h;\n x = (input_w - w) / 2;\n y = 0;\n }\n cv::Mat re(h, w, CV_8UC3);\n cv::resize(img, re, re.size(), 0, 0, cv::INTER_LINEAR);\n cv::Mat out(input_h, input_w, CV_8UC3, cv::Scalar(128, 128, 128));\n re.copyTo(out(cv::Rect(x, y, re.cols, re.rows)));\n return out;\n}\n\nstatic inline int read_files_in_dir(const char *p_dir_name, std::vector &file_names) {\n DIR *p_dir = opendir(p_dir_name);\n if (p_dir == nullptr) {\n return -1;\n }\n\n struct dirent* p_file = nullptr;\n while ((p_file = readdir(p_dir)) != nullptr) {\n if (strcmp(p_file->d_name, \".\") != 0 &&\n strcmp(p_file->d_name, \"..\") != 0) {\n //std::string cur_file_name(p_dir_name);\n //cur_file_name += \"/\";\n //cur_file_name += p_file->d_name;\n std::string cur_file_name(p_file->d_name);\n file_names.push_back(cur_file_name);\n }\n }\n\n closedir(p_dir);\n return 0;\n}\n\n#endif // TRTX_YOLOV5_UTILS_H_\n\n" }, { "path": "Jeston nano_tensorrt/yololayer.cu", "content": "#include \n#include \n#include \n#include \"yololayer.h\"\n#include \"cuda_utils.h\"\n\nnamespace Tn\n{\n template \n void write(char*& buffer, const T& val)\n {\n *reinterpret_cast(buffer) = val;\n buffer += sizeof(T);\n }\n\n template \n void read(const char*& buffer, T& val)\n {\n val = *reinterpret_cast(buffer);\n buffer += sizeof(T);\n }\n}\n\nusing namespace Yolo;\n\nnamespace nvinfer1\n{\n YoloLayerPlugin::YoloLayerPlugin(int classCount, int netWidth, int netHeight, int maxOut, const std::vector& vYoloKernel)\n {\n mClassCount = classCount;\n mYoloV5NetWidth = netWidth;\n mYoloV5NetHeight = netHeight;\n mMaxOutObject = maxOut;\n mYoloKernel = vYoloKernel;\n mKernelCount = vYoloKernel.size();\n\n CUDA_CHECK(cudaMallocHost(&mAnchor, mKernelCount * sizeof(void*)));\n size_t AnchorLen = sizeof(float)* CHECK_COUNT * 2;\n for (int ii = 0; ii < mKernelCount; ii++)\n {\n CUDA_CHECK(cudaMalloc(&mAnchor[ii], AnchorLen));\n const auto& yolo = mYoloKernel[ii];\n CUDA_CHECK(cudaMemcpy(mAnchor[ii], yolo.anchors, AnchorLen, cudaMemcpyHostToDevice));\n }\n }\n YoloLayerPlugin::~YoloLayerPlugin()\n {\n for (int ii = 0; ii < mKernelCount; ii++)\n {\n CUDA_CHECK(cudaFree(mAnchor[ii]));\n }\n CUDA_CHECK(cudaFreeHost(mAnchor));\n }\n\n // create the plugin at runtime from a byte stream\n YoloLayerPlugin::YoloLayerPlugin(const void* data, size_t length)\n {\n using namespace Tn;\n const char *d = reinterpret_cast(data), *a = d;\n read(d, mClassCount);\n read(d, mThreadCount);\n read(d, mKernelCount);\n read(d, mYoloV5NetWidth);\n read(d, mYoloV5NetHeight);\n read(d, mMaxOutObject);\n mYoloKernel.resize(mKernelCount);\n auto kernelSize = mKernelCount * sizeof(YoloKernel);\n memcpy(mYoloKernel.data(), d, kernelSize);\n d += kernelSize;\n CUDA_CHECK(cudaMallocHost(&mAnchor, mKernelCount * sizeof(void*)));\n size_t AnchorLen = sizeof(float)* CHECK_COUNT * 2;\n for (int ii = 0; ii < mKernelCount; ii++)\n {\n CUDA_CHECK(cudaMalloc(&mAnchor[ii], AnchorLen));\n const auto& yolo = mYoloKernel[ii];\n CUDA_CHECK(cudaMemcpy(mAnchor[ii], yolo.anchors, AnchorLen, cudaMemcpyHostToDevice));\n }\n assert(d == a + length);\n }\n\n void YoloLayerPlugin::serialize(void* buffer) const TRT_NOEXCEPT\n {\n using namespace Tn;\n char* d = static_cast(buffer), *a = d;\n write(d, mClassCount);\n write(d, mThreadCount);\n write(d, mKernelCount);\n write(d, mYoloV5NetWidth);\n write(d, mYoloV5NetHeight);\n write(d, mMaxOutObject);\n auto kernelSize = mKernelCount * sizeof(YoloKernel);\n memcpy(d, mYoloKernel.data(), kernelSize);\n d += kernelSize;\n\n assert(d == a + getSerializationSize());\n }\n\n size_t YoloLayerPlugin::getSerializationSize() const TRT_NOEXCEPT\n {\n return sizeof(mClassCount) + sizeof(mThreadCount) + sizeof(mKernelCount) + sizeof(Yolo::YoloKernel) * mYoloKernel.size() + sizeof(mYoloV5NetWidth) + sizeof(mYoloV5NetHeight) + sizeof(mMaxOutObject);\n }\n\n int YoloLayerPlugin::initialize() TRT_NOEXCEPT\n {\n return 0;\n }\n\n Dims YoloLayerPlugin::getOutputDimensions(int index, const Dims* inputs, int nbInputDims) TRT_NOEXCEPT\n {\n //output the result to channel\n int totalsize = mMaxOutObject * sizeof(Detection) / sizeof(float);\n\n return Dims3(totalsize + 1, 1, 1);\n }\n\n // Set plugin namespace\n void YoloLayerPlugin::setPluginNamespace(const char* pluginNamespace) TRT_NOEXCEPT\n {\n mPluginNamespace = pluginNamespace;\n }\n\n const char* YoloLayerPlugin::getPluginNamespace() const TRT_NOEXCEPT\n {\n return mPluginNamespace;\n }\n\n // Return the DataType of the plugin output at the requested index\n DataType YoloLayerPlugin::getOutputDataType(int index, const nvinfer1::DataType* inputTypes, int nbInputs) const TRT_NOEXCEPT\n {\n return DataType::kFLOAT;\n }\n\n // Return true if output tensor is broadcast across a batch.\n bool YoloLayerPlugin::isOutputBroadcastAcrossBatch(int outputIndex, const bool* inputIsBroadcasted, int nbInputs) const TRT_NOEXCEPT\n {\n return false;\n }\n\n // Return true if plugin can use input that is broadcast across batch without replication.\n bool YoloLayerPlugin::canBroadcastInputAcrossBatch(int inputIndex) const TRT_NOEXCEPT\n {\n return false;\n }\n\n void YoloLayerPlugin::configurePlugin(const PluginTensorDesc* in, int nbInput, const PluginTensorDesc* out, int nbOutput) TRT_NOEXCEPT\n {\n }\n\n // Attach the plugin object to an execution context and grant the plugin the access to some context resource.\n void YoloLayerPlugin::attachToContext(cudnnContext* cudnnContext, cublasContext* cublasContext, IGpuAllocator* gpuAllocator) TRT_NOEXCEPT\n {\n }\n\n // Detach the plugin object from its execution context.\n void YoloLayerPlugin::detachFromContext() TRT_NOEXCEPT {}\n\n const char* YoloLayerPlugin::getPluginType() const TRT_NOEXCEPT\n {\n return \"YoloLayer_TRT\";\n }\n\n const char* YoloLayerPlugin::getPluginVersion() const TRT_NOEXCEPT\n {\n return \"1\";\n }\n\n void YoloLayerPlugin::destroy() TRT_NOEXCEPT\n {\n delete this;\n }\n\n // Clone the plugin\n IPluginV2IOExt* YoloLayerPlugin::clone() const TRT_NOEXCEPT\n {\n YoloLayerPlugin* p = new YoloLayerPlugin(mClassCount, mYoloV5NetWidth, mYoloV5NetHeight, mMaxOutObject, mYoloKernel);\n p->setPluginNamespace(mPluginNamespace);\n return p;\n }\n\n __device__ float Logist(float data) { return 1.0f / (1.0f + expf(-data)); };\n\n __global__ void CalDetection(const float *input, float *output, int noElements,\n const int netwidth, const int netheight, int maxoutobject, int yoloWidth, int yoloHeight, const float anchors[CHECK_COUNT * 2], int classes, int outputElem)\n {\n\n int idx = threadIdx.x + blockDim.x * blockIdx.x;\n if (idx >= noElements) return;\n\n int total_grid = yoloWidth * yoloHeight;\n int bnIdx = idx / total_grid;\n idx = idx - total_grid * bnIdx;\n int info_len_i = 5 + classes;\n const float* curInput = input + bnIdx * (info_len_i * total_grid * CHECK_COUNT);\n\n for (int k = 0; k < CHECK_COUNT; ++k) {\n float box_prob = Logist(curInput[idx + k * info_len_i * total_grid + 4 * total_grid]);\n if (box_prob < IGNORE_THRESH) continue;\n int class_id = 0;\n float max_cls_prob = 0.0;\n for (int i = 5; i < info_len_i; ++i) {\n float p = Logist(curInput[idx + k * info_len_i * total_grid + i * total_grid]);\n if (p > max_cls_prob) {\n max_cls_prob = p;\n class_id = i - 5;\n }\n }\n float *res_count = output + bnIdx * outputElem;\n int count = (int)atomicAdd(res_count, 1);\n if (count >= maxoutobject) return;\n char *data = (char*)res_count + sizeof(float) + count * sizeof(Detection);\n Detection *det = (Detection*)(data);\n\n int row = idx / yoloWidth;\n int col = idx % yoloWidth;\n\n //Location\n // pytorch:\n // y = x[i].sigmoid()\n // y[..., 0:2] = (y[..., 0:2] * 2. - 0.5 + self.grid[i].to(x[i].device)) * self.stride[i] # xy\n // y[..., 2:4] = (y[..., 2:4] * 2) ** 2 * self.anchor_grid[i] # wh\n // X: (sigmoid(tx) + cx)/FeaturemapW * netwidth\n det->bbox[0] = (col - 0.5f + 2.0f * Logist(curInput[idx + k * info_len_i * total_grid + 0 * total_grid])) * netwidth / yoloWidth;\n det->bbox[1] = (row - 0.5f + 2.0f * Logist(curInput[idx + k * info_len_i * total_grid + 1 * total_grid])) * netheight / yoloHeight;\n\n // W: (Pw * e^tw) / FeaturemapW * netwidth\n // v5: https://github.com/ultralytics/yolov5/issues/471\n det->bbox[2] = 2.0f * Logist(curInput[idx + k * info_len_i * total_grid + 2 * total_grid]);\n det->bbox[2] = det->bbox[2] * det->bbox[2] * anchors[2 * k];\n det->bbox[3] = 2.0f * Logist(curInput[idx + k * info_len_i * total_grid + 3 * total_grid]);\n det->bbox[3] = det->bbox[3] * det->bbox[3] * anchors[2 * k + 1];\n det->conf = box_prob * max_cls_prob;\n det->class_id = class_id;\n }\n }\n\n void YoloLayerPlugin::forwardGpu(const float* const* inputs, float *output, cudaStream_t stream, int batchSize)\n {\n int outputElem = 1 + mMaxOutObject * sizeof(Detection) / sizeof(float);\n for (int idx = 0; idx < batchSize; ++idx) {\n CUDA_CHECK(cudaMemsetAsync(output + idx * outputElem, 0, sizeof(float), stream));\n }\n int numElem = 0;\n for (unsigned int i = 0; i < mYoloKernel.size(); ++i) {\n const auto& yolo = mYoloKernel[i];\n numElem = yolo.width * yolo.height * batchSize;\n if (numElem < mThreadCount) mThreadCount = numElem;\n\n //printf(\"Net: %d %d \\n\", mYoloV5NetWidth, mYoloV5NetHeight);\n CalDetection << < (numElem + mThreadCount - 1) / mThreadCount, mThreadCount, 0, stream >> >\n (inputs[i], output, numElem, mYoloV5NetWidth, mYoloV5NetHeight, mMaxOutObject, yolo.width, yolo.height, (float*)mAnchor[i], mClassCount, outputElem);\n }\n }\n\n\n int YoloLayerPlugin::enqueue(int batchSize, const void* const* inputs, void* TRT_CONST_ENQUEUE* outputs, void* workspace, cudaStream_t stream) TRT_NOEXCEPT\n {\n forwardGpu((const float* const*)inputs, (float*)outputs[0], stream, batchSize);\n return 0;\n }\n\n PluginFieldCollection YoloPluginCreator::mFC{};\n std::vector YoloPluginCreator::mPluginAttributes;\n\n YoloPluginCreator::YoloPluginCreator()\n {\n mPluginAttributes.clear();\n\n mFC.nbFields = mPluginAttributes.size();\n mFC.fields = mPluginAttributes.data();\n }\n\n const char* YoloPluginCreator::getPluginName() const TRT_NOEXCEPT\n {\n return \"YoloLayer_TRT\";\n }\n\n const char* YoloPluginCreator::getPluginVersion() const TRT_NOEXCEPT\n {\n return \"1\";\n }\n\n const PluginFieldCollection* YoloPluginCreator::getFieldNames() TRT_NOEXCEPT\n {\n return &mFC;\n }\n\n IPluginV2IOExt* YoloPluginCreator::createPlugin(const char* name, const PluginFieldCollection* fc) TRT_NOEXCEPT\n {\n assert(fc->nbFields == 2);\n assert(strcmp(fc->fields[0].name, \"netinfo\") == 0);\n assert(strcmp(fc->fields[1].name, \"kernels\") == 0);\n int *p_netinfo = (int*)(fc->fields[0].data);\n int class_count = p_netinfo[0];\n int input_w = p_netinfo[1];\n int input_h = p_netinfo[2];\n int max_output_object_count = p_netinfo[3];\n std::vector kernels(fc->fields[1].length);\n memcpy(&kernels[0], fc->fields[1].data, kernels.size() * sizeof(Yolo::YoloKernel));\n YoloLayerPlugin* obj = new YoloLayerPlugin(class_count, input_w, input_h, max_output_object_count, kernels);\n obj->setPluginNamespace(mNamespace.c_str());\n return obj;\n }\n\n IPluginV2IOExt* YoloPluginCreator::deserializePlugin(const char* name, const void* serialData, size_t serialLength) TRT_NOEXCEPT\n {\n // This object will be deleted when the network is destroyed, which will\n // call YoloLayerPlugin::destroy()\n YoloLayerPlugin* obj = new YoloLayerPlugin(serialData, serialLength);\n obj->setPluginNamespace(mNamespace.c_str());\n return obj;\n }\n}\n\n" }, { "path": "Jeston nano_tensorrt/yololayer.h", "content": "#ifndef _YOLO_LAYER_H\n#define _YOLO_LAYER_H\n\n#include \n#include \n#include \n#include \"macros.h\"\n\nnamespace Yolo\n{\n static constexpr int CHECK_COUNT = 3;\n static constexpr float IGNORE_THRESH = 0.1f;\n struct YoloKernel\n {\n int width;\n int height;\n float anchors[CHECK_COUNT * 2];\n };\n static constexpr int MAX_OUTPUT_BBOX_COUNT = 1000;\n static constexpr int CLASS_NUM = 80;\n static constexpr int INPUT_H = 480; // yolov5's input height and width must be divisible by 32.\n static constexpr int INPUT_W = 640;\n\n static constexpr int LOCATIONS = 4;\n struct alignas(float) Detection {\n //center_x center_y w h\n float bbox[LOCATIONS];\n float conf; // bbox_conf * cls_conf\n float class_id;\n };\n}\n\nnamespace nvinfer1\n{\n class API YoloLayerPlugin : public IPluginV2IOExt\n {\n public:\n YoloLayerPlugin(int classCount, int netWidth, int netHeight, int maxOut, const std::vector& vYoloKernel);\n YoloLayerPlugin(const void* data, size_t length);\n ~YoloLayerPlugin();\n\n int getNbOutputs() const TRT_NOEXCEPT override\n {\n return 1;\n }\n\n Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) TRT_NOEXCEPT override;\n\n int initialize() TRT_NOEXCEPT override;\n\n virtual void terminate() TRT_NOEXCEPT override {};\n\n virtual size_t getWorkspaceSize(int maxBatchSize) const TRT_NOEXCEPT override { return 0; }\n\n virtual int enqueue(int batchSize, const void* const* inputs, void*TRT_CONST_ENQUEUE* outputs, void* workspace, cudaStream_t stream) TRT_NOEXCEPT override;\n\n virtual size_t getSerializationSize() const TRT_NOEXCEPT override;\n\n virtual void serialize(void* buffer) const TRT_NOEXCEPT override;\n\n bool supportsFormatCombination(int pos, const PluginTensorDesc* inOut, int nbInputs, int nbOutputs) const TRT_NOEXCEPT override {\n return inOut[pos].format == TensorFormat::kLINEAR && inOut[pos].type == DataType::kFLOAT;\n }\n\n const char* getPluginType() const TRT_NOEXCEPT override;\n\n const char* getPluginVersion() const TRT_NOEXCEPT override;\n\n void destroy() TRT_NOEXCEPT override;\n\n IPluginV2IOExt* clone() const TRT_NOEXCEPT override;\n\n void setPluginNamespace(const char* pluginNamespace) TRT_NOEXCEPT override;\n\n const char* getPluginNamespace() const TRT_NOEXCEPT override;\n\n DataType getOutputDataType(int index, const nvinfer1::DataType* inputTypes, int nbInputs) const TRT_NOEXCEPT override;\n\n bool isOutputBroadcastAcrossBatch(int outputIndex, const bool* inputIsBroadcasted, int nbInputs) const TRT_NOEXCEPT override;\n\n bool canBroadcastInputAcrossBatch(int inputIndex) const TRT_NOEXCEPT override;\n\n void attachToContext(\n cudnnContext* cudnnContext, cublasContext* cublasContext, IGpuAllocator* gpuAllocator) TRT_NOEXCEPT override;\n\n void configurePlugin(const PluginTensorDesc* in, int nbInput, const PluginTensorDesc* out, int nbOutput) TRT_NOEXCEPT override;\n\n void detachFromContext() TRT_NOEXCEPT override;\n\n private:\n void forwardGpu(const float* const* inputs, float *output, cudaStream_t stream, int batchSize = 1);\n int mThreadCount = 256;\n const char* mPluginNamespace;\n int mKernelCount;\n int mClassCount;\n int mYoloV5NetWidth;\n int mYoloV5NetHeight;\n int mMaxOutObject;\n std::vector mYoloKernel;\n void** mAnchor;\n };\n\n class API YoloPluginCreator : public IPluginCreator\n {\n public:\n YoloPluginCreator();\n\n ~YoloPluginCreator() override = default;\n\n const char* getPluginName() const TRT_NOEXCEPT override;\n\n const char* getPluginVersion() const TRT_NOEXCEPT override;\n\n const PluginFieldCollection* getFieldNames() TRT_NOEXCEPT override;\n\n IPluginV2IOExt* createPlugin(const char* name, const PluginFieldCollection* fc) TRT_NOEXCEPT override;\n\n IPluginV2IOExt* deserializePlugin(const char* name, const void* serialData, size_t serialLength) TRT_NOEXCEPT override;\n\n void setPluginNamespace(const char* libNamespace) TRT_NOEXCEPT override\n {\n mNamespace = libNamespace;\n }\n\n const char* getPluginNamespace() const TRT_NOEXCEPT override\n {\n return mNamespace.c_str();\n }\n\n private:\n std::string mNamespace;\n static PluginFieldCollection mFC;\n static std::vector mPluginAttributes;\n };\n REGISTER_TENSORRT_PLUGIN(YoloPluginCreator);\n};\n\n#endif // _YOLO_LAYER_H\n" }, { "path": "Jeston nano_tensorrt/yolov5.cpp", "content": "#include \n#include \n#include \n#include \"cuda_utils.h\"\n#include \"logging.h\"\n#include \"common.hpp\"\n#include \"utils.h\"\n#include \"calibrator.h\"\n#include \"preprocess.h\"\n#include \"macros.h\"\n\n#define USE_FP16 // set USE_INT8 or USE_FP16 or USE_FP32\n#define DEVICE 0 // GPU id\n#define NMS_THRESH 0.4\n#define CONF_THRESH 0.5\n#define BATCH_SIZE 1\n#define MAX_IMAGE_INPUT_SIZE_THRESH 3000 * 3000 // ensure it exceed the maximum size in the input images !\n\n// stuff we know about the network and the input/output blobs\nstatic const int INPUT_H = Yolo::INPUT_H;\nstatic const int INPUT_W = Yolo::INPUT_W;\nstatic const int CLASS_NUM = Yolo::CLASS_NUM;\nstatic const int OUTPUT_SIZE = Yolo::MAX_OUTPUT_BBOX_COUNT * sizeof(Yolo::Detection) / sizeof(float) + 1; // we assume the yololayer outputs no more than MAX_OUTPUT_BBOX_COUNT boxes that conf >= 0.1\nconst char* INPUT_BLOB_NAME = \"data\";\nconst char* OUTPUT_BLOB_NAME = \"prob\";\nstatic Logger gLogger;\n\nstatic int get_width(int x, float gw, int divisor = 8) {\n return int(ceil((x * gw) / divisor)) * divisor;\n}\n\nstatic int get_depth(int x, float gd) {\n if (x == 1) return 1;\n int r = round(x * gd);\n if (x * gd - int(x * gd) == 0.5 && (int(x * gd) % 2) == 0) {\n --r;\n }\n return std::max(r, 1);\n}\n\nICudaEngine* build_engine(unsigned int maxBatchSize, IBuilder* builder, IBuilderConfig* config, DataType dt, float& gd, float& gw, std::string& wts_name) {\n INetworkDefinition* network = builder->createNetworkV2(0U);\n\n // Create input tensor of shape {3, INPUT_H, INPUT_W} with name INPUT_BLOB_NAME\n ITensor* data = network->addInput(INPUT_BLOB_NAME, dt, Dims3{ 3, INPUT_H, INPUT_W });\n assert(data);\n std::map weightMap = loadWeights(wts_name);\n /* ------ yolov5 backbone------ */\n auto conv0 = convBlock(network, weightMap, *data, get_width(64, gw), 6, 2, 1, \"model.0\");\n assert(conv0);\n auto conv1 = convBlock(network, weightMap, *conv0->getOutput(0), get_width(128, gw), 3, 2, 1, \"model.1\");\n auto bottleneck_CSP2 = C3(network, weightMap, *conv1->getOutput(0), get_width(128, gw), get_width(128, gw), get_depth(3, gd), true, 1, 0.5, \"model.2\");\n auto conv3 = convBlock(network, weightMap, *bottleneck_CSP2->getOutput(0), get_width(256, gw), 3, 2, 1, \"model.3\");\n auto bottleneck_csp4 = C3(network, weightMap, *conv3->getOutput(0), get_width(256, gw), get_width(256, gw), get_depth(6, gd), true, 1, 0.5, \"model.4\");\n auto conv5 = convBlock(network, weightMap, *bottleneck_csp4->getOutput(0), get_width(512, gw), 3, 2, 1, \"model.5\");\n auto bottleneck_csp6 = C3(network, weightMap, *conv5->getOutput(0), get_width(512, gw), get_width(512, gw), get_depth(9, gd), true, 1, 0.5, \"model.6\");\n auto conv7 = convBlock(network, weightMap, *bottleneck_csp6->getOutput(0), get_width(1024, gw), 3, 2, 1, \"model.7\");\n auto bottleneck_csp8 = C3(network, weightMap, *conv7->getOutput(0), get_width(1024, gw), get_width(1024, gw), get_depth(3, gd), true, 1, 0.5, \"model.8\");\n auto spp9 = SPPF(network, weightMap, *bottleneck_csp8->getOutput(0), get_width(1024, gw), get_width(1024, gw), 5, \"model.9\");\n /* ------ yolov5 head ------ */\n auto conv10 = convBlock(network, weightMap, *spp9->getOutput(0), get_width(512, gw), 1, 1, 1, \"model.10\");\n\n auto upsample11 = network->addResize(*conv10->getOutput(0));\n assert(upsample11);\n upsample11->setResizeMode(ResizeMode::kNEAREST);\n upsample11->setOutputDimensions(bottleneck_csp6->getOutput(0)->getDimensions());\n\n ITensor* inputTensors12[] = { upsample11->getOutput(0), bottleneck_csp6->getOutput(0) };\n auto cat12 = network->addConcatenation(inputTensors12, 2);\n auto bottleneck_csp13 = C3(network, weightMap, *cat12->getOutput(0), get_width(1024, gw), get_width(512, gw), get_depth(3, gd), false, 1, 0.5, \"model.13\");\n auto conv14 = convBlock(network, weightMap, *bottleneck_csp13->getOutput(0), get_width(256, gw), 1, 1, 1, \"model.14\");\n\n auto upsample15 = network->addResize(*conv14->getOutput(0));\n assert(upsample15);\n upsample15->setResizeMode(ResizeMode::kNEAREST);\n upsample15->setOutputDimensions(bottleneck_csp4->getOutput(0)->getDimensions());\n\n ITensor* inputTensors16[] = { upsample15->getOutput(0), bottleneck_csp4->getOutput(0) };\n auto cat16 = network->addConcatenation(inputTensors16, 2);\n\n auto bottleneck_csp17 = C3(network, weightMap, *cat16->getOutput(0), get_width(512, gw), get_width(256, gw), get_depth(3, gd), false, 1, 0.5, \"model.17\");\n\n /* ------ detect ------ */\n IConvolutionLayer* det0 = network->addConvolutionNd(*bottleneck_csp17->getOutput(0), 3 * (Yolo::CLASS_NUM + 5), DimsHW{ 1, 1 }, weightMap[\"model.24.m.0.weight\"], weightMap[\"model.24.m.0.bias\"]);\n auto conv18 = convBlock(network, weightMap, *bottleneck_csp17->getOutput(0), get_width(256, gw), 3, 2, 1, \"model.18\");\n ITensor* inputTensors19[] = { conv18->getOutput(0), conv14->getOutput(0) };\n auto cat19 = network->addConcatenation(inputTensors19, 2);\n auto bottleneck_csp20 = C3(network, weightMap, *cat19->getOutput(0), get_width(512, gw), get_width(512, gw), get_depth(3, gd), false, 1, 0.5, \"model.20\");\n IConvolutionLayer* det1 = network->addConvolutionNd(*bottleneck_csp20->getOutput(0), 3 * (Yolo::CLASS_NUM + 5), DimsHW{ 1, 1 }, weightMap[\"model.24.m.1.weight\"], weightMap[\"model.24.m.1.bias\"]);\n auto conv21 = convBlock(network, weightMap, *bottleneck_csp20->getOutput(0), get_width(512, gw), 3, 2, 1, \"model.21\");\n ITensor* inputTensors22[] = { conv21->getOutput(0), conv10->getOutput(0) };\n auto cat22 = network->addConcatenation(inputTensors22, 2);\n auto bottleneck_csp23 = C3(network, weightMap, *cat22->getOutput(0), get_width(1024, gw), get_width(1024, gw), get_depth(3, gd), false, 1, 0.5, \"model.23\");\n IConvolutionLayer* det2 = network->addConvolutionNd(*bottleneck_csp23->getOutput(0), 3 * (Yolo::CLASS_NUM + 5), DimsHW{ 1, 1 }, weightMap[\"model.24.m.2.weight\"], weightMap[\"model.24.m.2.bias\"]);\n\n auto yolo = addYoLoLayer(network, weightMap, \"model.24\", std::vector{det0, det1, det2});\n yolo->getOutput(0)->setName(OUTPUT_BLOB_NAME);\n network->markOutput(*yolo->getOutput(0));\n // Build engine\n builder->setMaxBatchSize(maxBatchSize);\n config->setMaxWorkspaceSize(16 * (1 << 20)); // 16MB\n#if defined(USE_FP16)\n config->setFlag(BuilderFlag::kFP16);\n#elif defined(USE_INT8)\n std::cout << \"Your platform support int8: \" << (builder->platformHasFastInt8() ? \"true\" : \"false\") << std::endl;\n assert(builder->platformHasFastInt8());\n config->setFlag(BuilderFlag::kINT8);\n Int8EntropyCalibrator2* calibrator = new Int8EntropyCalibrator2(1, INPUT_W, INPUT_H, \"./coco_calib/\", \"int8calib.table\", INPUT_BLOB_NAME);\n config->setInt8Calibrator(calibrator);\n#endif\n\n std::cout << \"Building engine, please wait for a while...\" << std::endl;\n ICudaEngine* engine = builder->buildEngineWithConfig(*network, *config);\n std::cout << \"Build engine successfully!\" << std::endl;\n\n // Don't need the network any more\n network->destroy();\n\n // Release host memory\n for (auto& mem : weightMap)\n {\n free((void*)(mem.second.values));\n }\n\n return engine;\n}\n\nICudaEngine* build_engine_p6(unsigned int maxBatchSize, IBuilder* builder, IBuilderConfig* config, DataType dt, float& gd, float& gw, std::string& wts_name) {\n INetworkDefinition* network = builder->createNetworkV2(0U);\n // Create input tensor of shape {3, INPUT_H, INPUT_W} with name INPUT_BLOB_NAME\n ITensor* data = network->addInput(INPUT_BLOB_NAME, dt, Dims3{ 3, INPUT_H, INPUT_W });\n assert(data);\n \n std::map weightMap = loadWeights(wts_name);\n\n /* ------ yolov5 backbone------ */\n auto conv0 = convBlock(network, weightMap, *data, get_width(64, gw), 6, 2, 1, \"model.0\");\n auto conv1 = convBlock(network, weightMap, *conv0->getOutput(0), get_width(128, gw), 3, 2, 1, \"model.1\");\n auto c3_2 = C3(network, weightMap, *conv1->getOutput(0), get_width(128, gw), get_width(128, gw), get_depth(3, gd), true, 1, 0.5, \"model.2\");\n auto conv3 = convBlock(network, weightMap, *c3_2->getOutput(0), get_width(256, gw), 3, 2, 1, \"model.3\");\n auto c3_4 = C3(network, weightMap, *conv3->getOutput(0), get_width(256, gw), get_width(256, gw), get_depth(6, gd), true, 1, 0.5, \"model.4\");\n auto conv5 = convBlock(network, weightMap, *c3_4->getOutput(0), get_width(512, gw), 3, 2, 1, \"model.5\");\n auto c3_6 = C3(network, weightMap, *conv5->getOutput(0), get_width(512, gw), get_width(512, gw), get_depth(9, gd), true, 1, 0.5, \"model.6\");\n auto conv7 = convBlock(network, weightMap, *c3_6->getOutput(0), get_width(768, gw), 3, 2, 1, \"model.7\");\n auto c3_8 = C3(network, weightMap, *conv7->getOutput(0), get_width(768, gw), get_width(768, gw), get_depth(3, gd), true, 1, 0.5, \"model.8\");\n auto conv9 = convBlock(network, weightMap, *c3_8->getOutput(0), get_width(1024, gw), 3, 2, 1, \"model.9\");\n auto c3_10 = C3(network, weightMap, *conv9->getOutput(0), get_width(1024, gw), get_width(1024, gw), get_depth(3, gd), true, 1, 0.5, \"model.10\");\n auto sppf11 = SPPF(network, weightMap, *c3_10->getOutput(0), get_width(1024, gw), get_width(1024, gw), 5, \"model.11\");\n\n /* ------ yolov5 head ------ */\n auto conv12 = convBlock(network, weightMap, *sppf11->getOutput(0), get_width(768, gw), 1, 1, 1, \"model.12\");\n auto upsample13 = network->addResize(*conv12->getOutput(0));\n assert(upsample13);\n upsample13->setResizeMode(ResizeMode::kNEAREST);\n upsample13->setOutputDimensions(c3_8->getOutput(0)->getDimensions());\n ITensor* inputTensors14[] = { upsample13->getOutput(0), c3_8->getOutput(0) };\n auto cat14 = network->addConcatenation(inputTensors14, 2);\n auto c3_15 = C3(network, weightMap, *cat14->getOutput(0), get_width(1536, gw), get_width(768, gw), get_depth(3, gd), false, 1, 0.5, \"model.15\");\n\n auto conv16 = convBlock(network, weightMap, *c3_15->getOutput(0), get_width(512, gw), 1, 1, 1, \"model.16\");\n auto upsample17 = network->addResize(*conv16->getOutput(0));\n assert(upsample17);\n upsample17->setResizeMode(ResizeMode::kNEAREST);\n upsample17->setOutputDimensions(c3_6->getOutput(0)->getDimensions());\n ITensor* inputTensors18[] = { upsample17->getOutput(0), c3_6->getOutput(0) };\n auto cat18 = network->addConcatenation(inputTensors18, 2);\n auto c3_19 = C3(network, weightMap, *cat18->getOutput(0), get_width(1024, gw), get_width(512, gw), get_depth(3, gd), false, 1, 0.5, \"model.19\");\n\n auto conv20 = convBlock(network, weightMap, *c3_19->getOutput(0), get_width(256, gw), 1, 1, 1, \"model.20\");\n auto upsample21 = network->addResize(*conv20->getOutput(0));\n assert(upsample21);\n upsample21->setResizeMode(ResizeMode::kNEAREST);\n upsample21->setOutputDimensions(c3_4->getOutput(0)->getDimensions());\n ITensor* inputTensors21[] = { upsample21->getOutput(0), c3_4->getOutput(0) };\n auto cat22 = network->addConcatenation(inputTensors21, 2);\n auto c3_23 = C3(network, weightMap, *cat22->getOutput(0), get_width(512, gw), get_width(256, gw), get_depth(3, gd), false, 1, 0.5, \"model.23\");\n\n auto conv24 = convBlock(network, weightMap, *c3_23->getOutput(0), get_width(256, gw), 3, 2, 1, \"model.24\");\n ITensor* inputTensors25[] = { conv24->getOutput(0), conv20->getOutput(0) };\n auto cat25 = network->addConcatenation(inputTensors25, 2);\n auto c3_26 = C3(network, weightMap, *cat25->getOutput(0), get_width(1024, gw), get_width(512, gw), get_depth(3, gd), false, 1, 0.5, \"model.26\");\n\n auto conv27 = convBlock(network, weightMap, *c3_26->getOutput(0), get_width(512, gw), 3, 2, 1, \"model.27\");\n ITensor* inputTensors28[] = { conv27->getOutput(0), conv16->getOutput(0) };\n auto cat28 = network->addConcatenation(inputTensors28, 2);\n auto c3_29 = C3(network, weightMap, *cat28->getOutput(0), get_width(1536, gw), get_width(768, gw), get_depth(3, gd), false, 1, 0.5, \"model.29\");\n\n auto conv30 = convBlock(network, weightMap, *c3_29->getOutput(0), get_width(768, gw), 3, 2, 1, \"model.30\");\n ITensor* inputTensors31[] = { conv30->getOutput(0), conv12->getOutput(0) };\n auto cat31 = network->addConcatenation(inputTensors31, 2);\n auto c3_32 = C3(network, weightMap, *cat31->getOutput(0), get_width(2048, gw), get_width(1024, gw), get_depth(3, gd), false, 1, 0.5, \"model.32\");\n\n /* ------ detect ------ */\n IConvolutionLayer* det0 = network->addConvolutionNd(*c3_23->getOutput(0), 3 * (Yolo::CLASS_NUM + 5), DimsHW{ 1, 1 }, weightMap[\"model.33.m.0.weight\"], weightMap[\"model.33.m.0.bias\"]);\n IConvolutionLayer* det1 = network->addConvolutionNd(*c3_26->getOutput(0), 3 * (Yolo::CLASS_NUM + 5), DimsHW{ 1, 1 }, weightMap[\"model.33.m.1.weight\"], weightMap[\"model.33.m.1.bias\"]);\n IConvolutionLayer* det2 = network->addConvolutionNd(*c3_29->getOutput(0), 3 * (Yolo::CLASS_NUM + 5), DimsHW{ 1, 1 }, weightMap[\"model.33.m.2.weight\"], weightMap[\"model.33.m.2.bias\"]);\n IConvolutionLayer* det3 = network->addConvolutionNd(*c3_32->getOutput(0), 3 * (Yolo::CLASS_NUM + 5), DimsHW{ 1, 1 }, weightMap[\"model.33.m.3.weight\"], weightMap[\"model.33.m.3.bias\"]);\n\n auto yolo = addYoLoLayer(network, weightMap, \"model.33\", std::vector{det0, det1, det2, det3});\n yolo->getOutput(0)->setName(OUTPUT_BLOB_NAME);\n network->markOutput(*yolo->getOutput(0));\n\n // Build engine\n builder->setMaxBatchSize(maxBatchSize);\n config->setMaxWorkspaceSize(16 * (1 << 20)); // 16MB\n#if defined(USE_FP16)\n config->setFlag(BuilderFlag::kFP16);\n#elif defined(USE_INT8)\n std::cout << \"Your platform support int8: \" << (builder->platformHasFastInt8() ? \"true\" : \"false\") << std::endl;\n assert(builder->platformHasFastInt8());\n config->setFlag(BuilderFlag::kINT8);\n Int8EntropyCalibrator2* calibrator = new Int8EntropyCalibrator2(1, INPUT_W, INPUT_H, \"./coco_calib/\", \"int8calib.table\", INPUT_BLOB_NAME);\n config->setInt8Calibrator(calibrator);\n#endif\n\n std::cout << \"Building engine, please wait for a while...\" << std::endl;\n ICudaEngine* engine = builder->buildEngineWithConfig(*network, *config);\n std::cout << \"Build engine successfully!\" << std::endl;\n\n // Don't need the network any more\n network->destroy();\n\n // Release host memory\n for (auto& mem : weightMap)\n {\n free((void*)(mem.second.values));\n }\n\n return engine;\n}\n\nvoid APIToModel(unsigned int maxBatchSize, IHostMemory** modelStream, bool& is_p6, float& gd, float& gw, std::string& wts_name) {\n // Create builder\n IBuilder* builder = createInferBuilder(gLogger);\n IBuilderConfig* config = builder->createBuilderConfig();\n\n // Create model to populate the network, then set the outputs and create an engine\n ICudaEngine *engine = nullptr;\n if (is_p6) {\n engine = build_engine_p6(maxBatchSize, builder, config, DataType::kFLOAT, gd, gw, wts_name);\n } else {\n engine = build_engine(maxBatchSize, builder, config, DataType::kFLOAT, gd, gw, wts_name);\n }\n assert(engine != nullptr);\n\n // Serialize the engine\n (*modelStream) = engine->serialize();\n\n // Close everything down\n engine->destroy();\n builder->destroy();\n config->destroy();\n}\n\n//void doInference(IExecutionContext& context, cudaStream_t& stream, void **buffers, float* output, int batchSize) {\n// // infer on the batch asynchronously, and DMA output back to host\n// context.enqueue(batchSize, buffers, stream, nullptr);\n// CUDA_CHECK(cudaMemcpyAsync(output, buffers[1], batchSize * OUTPUT_SIZE * sizeof(float), cudaMemcpyDeviceToHost, stream));\n// cudaStreamSynchronize(stream);\n//}\n\nvoid doInference(IExecutionContext& context, cudaStream_t& stream, void **buffers, float* input, float* output, int batchSize) {\n\t// DMA input batch data to device, infer on the batch asynchronously, and DMA output back to host\n\tCUDA_CHECK(cudaMemcpyAsync(buffers[0], input, batchSize * 3 * INPUT_H * INPUT_W * sizeof(float), cudaMemcpyHostToDevice, stream));\n\tcontext.enqueue(batchSize, buffers, stream, nullptr);\n\tCUDA_CHECK(cudaMemcpyAsync(output, buffers[1], batchSize * OUTPUT_SIZE * sizeof(float), cudaMemcpyDeviceToHost, stream));\n\tcudaStreamSynchronize(stream);\n}\n\nbool parse_args(int argc, char** argv, std::string& wts, std::string& engine, bool& is_p6, float& gd, float& gw, std::string& img_dir) {\n if (argc < 4) return false;\n if (std::string(argv[1]) == \"-s\" && (argc == 5 || argc == 7)) {\n wts = std::string(argv[2]);\n engine = std::string(argv[3]);\n auto net = std::string(argv[4]);\n if (net[0] == 'n') {\n gd = 0.33;\n gw = 0.25;\n } else if (net[0] == 's') {\n gd = 0.33;\n gw = 0.50;\n } else if (net[0] == 'm') {\n gd = 0.67;\n gw = 0.75;\n } else if (net[0] == 'l') {\n gd = 1.0;\n gw = 1.0;\n } else if (net[0] == 'x') {\n gd = 1.33;\n gw = 1.25;\n } else if (net[0] == 'c' && argc == 7) {\n gd = atof(argv[5]);\n gw = atof(argv[6]);\n } else {\n return false;\n }\n if (net.size() == 2 && net[1] == '6') {\n is_p6 = true;\n }\n } else if (std::string(argv[1]) == \"-d\" && argc == 4) {\n engine = std::string(argv[2]);\n img_dir = std::string(argv[3]);\n } else {\n return false;\n }\n return true;\n}\n\nint main(int argc, char** argv) {\n cudaSetDevice(DEVICE);\n std::string wts_name = \"\";\n std::string engine_name = \"\";\n bool is_p6 = false;\n float gd = 0.0f, gw = 0.0f;\n std::string img_dir;\n if (!parse_args(argc, argv, wts_name, engine_name, is_p6, gd, gw, img_dir)) {\n std::cerr << \"arguments not right!\" << std::endl;\n std::cerr << \"./yolov5 -s [.wts] [.engine] [n/s/m/l/x/n6/s6/m6/l6/x6 or c/c6 gd gw] // serialize model to plan file\" << std::endl;\n std::cerr << \"./yolov5 -d [.engine] ../samples // deserialize plan file and run inference\" << std::endl;\n return -1;\n }\n\n // create a model using the API directly and serialize it to a stream\n if (!wts_name.empty()) {\n IHostMemory* modelStream{ nullptr };\n APIToModel(BATCH_SIZE, &modelStream, is_p6, gd, gw, wts_name);\n assert(modelStream != nullptr);\n std::ofstream p(engine_name, std::ios::binary);\n if (!p) {\n std::cerr << \"could not open plan output file\" << std::endl;\n return -1;\n }\n p.write(reinterpret_cast(modelStream->data()), modelStream->size());\n modelStream->destroy();\n return 0;\n }\n\n // deserialize the .engine and run inference\n std::ifstream file(engine_name, std::ios::binary);\n if (!file.good()) {\n std::cerr << \"read \" << engine_name << \" error!\" << std::endl;\n return -1;\n }\n\tchar *trtModelStream = nullptr;\n\tsize_t size = 0;\n\tfile.seekg(0, file.end);\n\tsize = file.tellg();\n\tfile.seekg(0, file.beg);\n\ttrtModelStream = new char[size];\n\tassert(trtModelStream);\n\tfile.read(trtModelStream, size);\n\tfile.close();\n\n\tstd::vector file_names;\n\tif (read_files_in_dir(img_dir.c_str(), file_names) < 0) {\n\t\tstd::cerr << \"read_files_in_dir failed.\" << std::endl;\n\t\treturn -1;\n\t}\n\n\t// prepare input data ---------------------------\n\tstatic float data[BATCH_SIZE * 3 * INPUT_H * INPUT_W];\n\t//for (int i = 0; i < 3 * INPUT_H * INPUT_W; i++)\n\t// data[i] = 1.0;\n\tstatic float prob[BATCH_SIZE * OUTPUT_SIZE];\n\tIRuntime* runtime = createInferRuntime(gLogger);\n\tassert(runtime != nullptr);\n\tICudaEngine* engine = runtime->deserializeCudaEngine(trtModelStream, size);\n\tassert(engine != nullptr);\n\tIExecutionContext* context = engine->createExecutionContext();\n\tassert(context != nullptr);\n\tdelete[] trtModelStream;\n\tassert(engine->getNbBindings() == 2);\n\tvoid* buffers[2];\n\t// In order to bind the buffers, we need to know the names of the input and output tensors.\n\t// Note that indices are guaranteed to be less than IEngine::getNbBindings()\n\tconst int inputIndex = engine->getBindingIndex(INPUT_BLOB_NAME);\n\tconst int outputIndex = engine->getBindingIndex(OUTPUT_BLOB_NAME);\n\tassert(inputIndex == 0);\n\tassert(outputIndex == 1);\n\t// Create GPU buffers on device\n\tCUDA_CHECK(cudaMalloc(&buffers[inputIndex], BATCH_SIZE * 3 * INPUT_H * INPUT_W * sizeof(float)));\n\tCUDA_CHECK(cudaMalloc(&buffers[outputIndex], BATCH_SIZE * OUTPUT_SIZE * sizeof(float)));\n\t// Create stream\n\tcudaStream_t stream;\n\tCUDA_CHECK(cudaStreamCreate(&stream));\n\n\tint fcount = 0;\n\tfor (int f = 0; f < (int)file_names.size(); f++) {\n\t\tfcount++;\n\t\tif (fcount < BATCH_SIZE && f + 1 != (int)file_names.size()) continue;\n\t\tfor (int b = 0; b < fcount; b++) {\n\t\t\tcv::Mat img = cv::imread(img_dir + \"/\" + file_names[f - fcount + 1 + b]);\n\t\t\tif (img.empty()) continue;\n\t\t\tcv::Mat pr_img = preprocess_img(img, INPUT_W, INPUT_H); // letterbox BGR to RGB\n\t\t\tint i = 0;\n\t\t\tfor (int row = 0; row < INPUT_H; ++row) {\n\t\t\t\tuchar* uc_pixel = pr_img.data + row * pr_img.step;\n\t\t\t\tfor (int col = 0; col < INPUT_W; ++col) {\n\t\t\t\t\tdata[b * 3 * INPUT_H * INPUT_W + i] = (float)uc_pixel[2] / 255.0;\n\t\t\t\t\tdata[b * 3 * INPUT_H * INPUT_W + i + INPUT_H * INPUT_W] = (float)uc_pixel[1] / 255.0;\n\t\t\t\t\tdata[b * 3 * INPUT_H * INPUT_W + i + 2 * INPUT_H * INPUT_W] = (float)uc_pixel[0] / 255.0;\n\t\t\t\t\tuc_pixel += 3;\n\t\t\t\t\t++i;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// Run inference\n\t\tauto start = std::chrono::system_clock::now();\n\t\tdoInference(*context, stream, buffers, data, prob, BATCH_SIZE);\n\t\tauto end = std::chrono::system_clock::now();\n\t\tstd::cout << std::chrono::duration_cast(end - start).count() << \"ms\" << std::endl;\n\t\tstd::vector> batch_res(fcount);\n\t\tfor (int b = 0; b < fcount; b++) {\n\t\t\tauto& res = batch_res[b];\n\t\t\tnms(res, &prob[b * OUTPUT_SIZE], CONF_THRESH, NMS_THRESH);\n\t\t}\n\t\tfor (int b = 0; b < fcount; b++) {\n\t\t\tauto& res = batch_res[b];\n\t\t\t//std::cout << res.size() << std::endl;\n\t\t\tcv::Mat img = cv::imread(img_dir + \"/\" + file_names[f - fcount + 1 + b]);\n\t\t\tfor (size_t j = 0; j < res.size(); j++) {\n\t\t\t\tcv::Rect r = get_rect(img, res[j].bbox);\n\t\t\t\tcv::rectangle(img, r, cv::Scalar(0x27, 0xC1, 0x36), 2);\n\t\t\t\tcv::putText(img, std::to_string((int)res[j].class_id), cv::Point(r.x, r.y - 1), cv::FONT_HERSHEY_PLAIN, 1.2, cv::Scalar(0xFF, 0xFF, 0xFF), 2);\n\t\t\t}\n\t\t\tcv::imwrite(\"_\" + file_names[f - fcount + 1 + b], img);\n\t\t}\n\t\tfcount = 0;\n\t}\n\n\t// Release stream and buffers\n\tcudaStreamDestroy(stream);\n\tCUDA_CHECK(cudaFree(buffers[inputIndex]));\n\tCUDA_CHECK(cudaFree(buffers[outputIndex]));\n\t// Destroy the engine\n\tcontext->destroy();\n\tengine->destroy();\n\truntime->destroy();\n\n\t// Print histogram of the output distribution\n\t//std::cout << \"\\nOutput:\\n\\n\";\n\t//for (unsigned int i = 0; i < OUTPUT_SIZE; i++)\n\t//{\n\t// std::cout << prob[i] << \", \";\n\t// if (i % 10 == 0) std::cout << std::endl;\n\t//}\n\t//std::cout << std::endl;\n\n\treturn 0;\n}\n\ntypedef struct\n{\n\n\tfloat *data;\n\tfloat *prob;\n\tIRuntime *runtime;\n\tICudaEngine *engine;\n\tIExecutionContext *context;\n\tvoid* buffers[2];\n\tcudaStream_t stream;\n\tint inputIndex;\n\tint outputIndex;\n\n}Yolov5TRTContext;\n\nextern \"C\" API void* Init(char *model_path)\n{\n\tcudaSetDevice(DEVICE);\n\t// create a model using the API directly and serialize it to a stream\n\tchar *trtModelStream{ nullptr };\n\tsize_t size_e{ 0 };\n\tstd::string engine_name = model_path;\n\tstd::ifstream file(engine_name, std::ios::binary);\n\tYolov5TRTContext * trt = new Yolov5TRTContext();\n\tif (file.good()) {\n\t\tfile.seekg(0, file.end);\n\t\tsize_e = file.tellg();\n\t\tfile.seekg(0, file.beg);\n\t\ttrtModelStream = new char[size_e];\n\t\tassert(trtModelStream);\n\t\tfile.read(trtModelStream, size_e);\n\t\tfile.close();\n\t}\n\n\ttrt->runtime = createInferRuntime(gLogger);\n\tassert(trt->runtime != nullptr);\n\ttrt->engine = trt->runtime->deserializeCudaEngine(trtModelStream, size_e);\n\tassert(trt->engine != nullptr);\n\ttrt->context = trt->engine->createExecutionContext();\n\tassert(trt->context != nullptr);\n\t//delete[] trtModelStream;\n\tassert(trt->engine->getNbBindings() == 2);\n\ttrt->data = new float[BATCH_SIZE * 3 * INPUT_H * INPUT_W];\n\ttrt->prob = new float[BATCH_SIZE * OUTPUT_SIZE];\n\ttrt->inputIndex = trt->engine->getBindingIndex(INPUT_BLOB_NAME);\n\ttrt->outputIndex = trt->engine->getBindingIndex(OUTPUT_BLOB_NAME);\n\tassert(trt->inputIndex == 0);\n\tassert(trt->outputIndex == 1);\n\t// Create GPU buffers on device\n\tCUDA_CHECK(cudaMalloc(&trt->buffers[trt->inputIndex], BATCH_SIZE * 3 * INPUT_H * INPUT_W * sizeof(float)));\n\tCUDA_CHECK(cudaMalloc(&trt->buffers[trt->outputIndex], BATCH_SIZE * OUTPUT_SIZE * sizeof(float)));\n\t// Create stream\n\tCUDA_CHECK(cudaStreamCreate(&trt->stream));\n\n\t// In order to bind the buffers, we need to know the names of the input and output tensors.\n\t// Note that indices are guaranteed to be less than IEngine::getNbBindings()\n\treturn (void*)trt;\n}\n\n\nextern \"C\" API void Detect(void *h, int rows, int cols, unsigned char *src_data, float(*res_array)[6])\n{\n\tYolov5TRTContext *trt = (Yolov5TRTContext *)h;\n\tcv::Mat img = cv::Mat(rows, cols, CV_8UC3, src_data);\n\t// prepare input data ---------------------------\n\tcv::Mat pr_img = preprocess_img(img, INPUT_W, INPUT_H); // letterbox BGR to RGB\n\tint i = 0;\n\tfor (int row = 0; row < INPUT_H; ++row) {\n\t\tuchar* uc_pixel = pr_img.data + row * pr_img.step;\n\t\tfor (int col = 0; col < INPUT_W; ++col)\n\t\t{\n\t\t\ttrt->data[0 * 3 * INPUT_H * INPUT_W + i] = (float)uc_pixel[2] / 255.0;\n\t\t\ttrt->data[0 * 3 * INPUT_H * INPUT_W + i + INPUT_H * INPUT_W] = (float)uc_pixel[1] / 255.0;\n\t\t\ttrt->data[0 * 3 * INPUT_H * INPUT_W + i + 2 * INPUT_H * INPUT_W] = (float)uc_pixel[0] / 255.0;\n\t\t\tuc_pixel += 3;\n\t\t\t++i;\n\t\t}\n\t}\n\n\t// Run inference\n\tdoInference(*trt->context, trt->stream, trt->buffers, trt->data, trt->prob, BATCH_SIZE);\n\n\tstd::vector> batch_res(1);\n\tauto& res = batch_res[0];\n\tnms(res, &trt->prob[0 * OUTPUT_SIZE], CONF_THRESH, NMS_THRESH);\n\tint len = res.size();\n\tfor (size_t j = 0; j < res.size(); j++) {\n\t\tcv::Rect r = get_rect(img, res[j].bbox);\n\t\tres_array[j][0] = r.x;\n\t\tres_array[j][1] = r.y;\n\t\tres_array[j][2] = r.width;\n\t\tres_array[j][3] = r.height;\n\t\tres_array[j][4] = res[j].class_id;\n\t\tres_array[j][5] = res[j].conf;\n\t}\n}\n\nextern \"C\" API void cuda_free(void*h) {\n\tYolov5TRTContext *trt = (Yolov5TRTContext *)h;\n\tcudaStreamDestroy(trt->stream);\n\tCUDA_CHECK(cudaFree(trt->buffers[trt->inputIndex]));\n\tCUDA_CHECK(cudaFree(trt->buffers[trt->outputIndex]));\n\ttrt->context->destroy();\n\ttrt->engine->destroy();\n\ttrt->runtime->destroy();\n}" }, { "path": "Jeston nano_tensorrt/部署/python_trt.py", "content": "from ctypes import *\nimport cv2\nimport numpy as np\nimport numpy.ctypeslib as npct\nimport time\nimport math\nfrom PIL import Image\n\n# -----------------------------------双目相机的基本参数---------------------------------------------------------\n# left_camera_matrix 左相机的内参矩阵\n# right_camera_matrix 右相机的内参矩阵\n#\n# left_distortion 左相机的畸变系数 格式(K1,K2,P1,P2,0)\n# right_distortion 右相机的畸变系数\n# -------------------------------------------------------------------------------------------------------------\n# 左镜头的内参，如焦距\nleft_camera_matrix = np.array([[516.5066236,-1.444673028,320.2950423],[0,516.5816117,270.7881873],[0.,0.,1.]])\nright_camera_matrix = np.array([[511.8428182,1.295112628,317.310253],[0,513.0748795,269.5885026],[0.,0.,1.]])\n\n# 畸变系数,K1、K2、K3为径向畸变,P1、P2为切向畸变\nleft_distortion = np.array([[-0.046645194,0.077595167, 0.012476819,-0.000711358,0]])\nright_distortion = np.array([[-0.061588946,0.122384376,0.011081232,-0.000750439,0]])\n\n# 旋转矩阵\nR = np.array([[0.999911333,-0.004351508,0.012585312],\n [0.004184066,0.999902792,0.013300386],\n [-0.012641965,-0.013246549,0.999832341]])\n# 平移矩阵\nT = np.array([-120.3559901,-0.188953775,-0.662073075])\nsize = (640, 480)\n\nR1, R2, P1, P2, Q, validPixROI1, validPixROI2 = cv2.stereoRectify(left_camera_matrix, left_distortion,\n right_camera_matrix, right_distortion, size, R,\n T)\n# 校正查找映射表,将原始图像和校正后的图像上的点一一对应起来\nleft_map1, left_map2 = cv2.initUndistortRectifyMap(left_camera_matrix, left_distortion, R1, P1, size, cv2.CV_16SC2)\nright_map1, right_map2 = cv2.initUndistortRectifyMap(right_camera_matrix, right_distortion, R2, P2, size, cv2.CV_16SC2)\nprint(Q)\n\n# ---------------------------------------------------------------------------------------------------------\n# classes coco数据集的种类,网络返回‘0’时，对应着person，依次类推\n# ---------------------------------------------------------------------------------------------------------\nclasses = ('person','bicycle','car','motorbike','aeroplane','bus','train','truck','boat','traffic light',\n'fire hydrant','stop sign','parking meter','bench','bird','cat','dog','horse','sheep','cow','elephant',\n'bear','zebra','giraffe','backpack','umbrella','handbag','tie','suitcase','frisbee','skis','snowboard',\n'sports ball','kite','baseball bat','baseball glove','skateboard','surfboard','tennis racket','bottle',\n'wine glass','cup','fork','knife','spoon','bowl','banana','apple','sandwich','orange','broccoli','carrot',\n'hot dog','pizza','donut','cake','chair','sofa','pottedplant','bed','diningtable','toilet','tvmonitor',\n'laptop','mouse','remote','keyboard','cell phone','microwave','oven','toaster','sink','refrigerator',\n'book','clock','vase','scissors','teddy bear','hair drier','toothbrush')\n\n\n# ---------------------------------------------------------------------------------------------------------\n# Detector() 配置tensorrt加速\n# ---------------------------------------------------------------------------------------------------------\nclass Detector():\n def __init__(self,model_path,dll_path):\n self.yolov5 = CDLL(dll_path)\n self.yolov5.Detect.argtypes = [c_void_p,c_int,c_int,POINTER(c_ubyte),npct.ndpointer(dtype = np.float32, ndim = 2, shape = (50, 6), flags=\"C_CONTIGUOUS\")]\n self.yolov5.Init.restype = c_void_p\n self.yolov5.Init.argtypes = [c_void_p]\n self.yolov5.cuda_free.argtypes = [c_void_p]\n self.c_point = self.yolov5.Init(model_path)\n\n def predict(self,img):\n rows, cols = img.shape[0], img.shape[1]\n res_arr = np.zeros((50,6),dtype=np.float32)\n self.yolov5.Detect(self.c_point,c_int(rows), c_int(cols), img.ctypes.data_as(POINTER(c_ubyte)),res_arr)\n self.bbox_array = res_arr[~(res_arr==0).all(1)]\n return self.bbox_array\n\n def free(self):\n self.yolov5.cuda_free(self.c_point)\n\n# ------------------------------------visualize可视化程序-------------------------------------------------------\n# img 输入的图片\n# bbox_array 多组yolo网络预测的结果\n# middle_x、middle_y 检测目标的中心点坐标，用于测出距离distance\n# -------------------------------------------------------------------------------------------------------------\ndef visualize(img,bbox_array):\n for temp in bbox_array:\n bbox = [temp[0],temp[1],temp[2],temp[3]] #xywh\n clas = int(temp[4])\n score = temp[5]\n\n middle_x = int(np.floor(temp[0]+temp[2]*0.5))\n middle_y = int(np.floor(temp[1]+temp[3]*0.5))\n\n distance = math.sqrt(threeD[middle_y][middle_x][0] ** 2 +\n threeD[middle_y][middle_x][1] ** 2 + threeD[middle_y][middle_x][2] ** 2)\n distance = distance / 1000.0 # mm -> m\n\n cv2.rectangle(img,(int(temp[0]),int(temp[1])),(int(temp[0]+temp[2]),int(temp[1]+temp[3])), (0, 0, 225), 2)\n img = cv2.putText(img, str(classes[int(clas)])+\" \"+str(round(score,2))+\" dis=\"+str(round(distance,2)),\n (int(temp[0]),int(temp[1])-5), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 225), 2)\n\n return img\n\n#---------------------------------------------------#\n# 对输入图像进行不失真resize\n#---------------------------------------------------#\ndef resize_image(image, size):\n iw, ih = image.size\n w, h = size\n scale = min(w/iw, h/ih)\n nw = int(iw*scale)\n nh = int(ih*scale)\n\n image = image.resize((nw,nh), Image.BICUBIC)\n new_image = Image.new('RGB', size, (128,128,128))\n new_image.paste(image, ((w-nw)//2, (h-nh)//2))\n return new_image\n\n#----------------------加载推理所需要的engine、dll文件---------------------------------#\n# yolov5s_480 图片推理的输入格式为640x480\n# yolov5 图片推理的输入格式为640x640，若使用它，需要打开182行的resize函数\n#------------------------------------------------------------------------------------#\ndet = Detector(model_path=b\"./yolov5s.engine\",dll_path=\"./libyolov5.so\") # b'' is needed\n# 加载视频文件\ncapture = cv2.VideoCapture(\"car.avi\")\nWIN_NAME = 'Deep disp'\ncv2.namedWindow(WIN_NAME, cv2.WINDOW_AUTOSIZE)\n\n# 3 读取视频\nfps = 0.0\nret, frame = capture.read()\n\nwhile ret:\n # 是否读取到了帧，读取到了则为True\n ret, frame = capture.read()\n # 开始计时，用于计算帧率\n t1 = time.time()\n img_color = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)\n frame1 = frame[0:480, 0:640]\n frame2 = frame[0:480, 640:1280] # 割开双目图像\n\n imgL = cv2.cvtColor(frame1, cv2.COLOR_BGR2GRAY) # 将BGR格式转换成灰度图片\n imgR = cv2.cvtColor(frame2, cv2.COLOR_BGR2GRAY)\n\n # cv2.remap 重映射，就是把一幅图像中某位置的像素放置到另一个图片指定位置的过程。\n # 依据MATLAB测量数据重建无畸变图片\n img1_rectified = cv2.remap(imgL, left_map1, left_map2, cv2.INTER_LINEAR)\n img2_rectified = cv2.remap(imgR, right_map1, right_map2, cv2.INTER_LINEAR)\n\n imageL = cv2.cvtColor(img1_rectified, cv2.COLOR_GRAY2BGR)\n imageR = cv2.cvtColor(img2_rectified, cv2.COLOR_GRAY2BGR)\n\n # ------------------------------------SGBM算法----------------------------------------------------------\n # blockSize 深度图成块，blocksize越低，其深度图就越零碎，0\r\n\r\n## 项目日志\r\n\r\n- [x] 双目相机的标定和初始化（2022.7.3）\r\n- [x] 运行BM、SGBM算法（2022.7.6）\r\n- [x] 研究SGBM算法并得出良好的open3d模型（2022.7.15）\r\n- [x] 实现双目测距（2022.7.27）\r\n- [x] 双目相机测出Yolov5检测物体的距离（2022.7.29）\r\n- [x] 视频帧率提高至6FPS（2022.7.30）\r\n- [x] 使用C++重勾BM算法（2022.8.1）\r\n- [x] 使用C++重构SGBM算法（2022.8.1）\r\n- [x] 使用TensorRT、C++部署yolov5模型（2022.8.3）\r\n- [x] 完成项目，帧率至少达到20FPS（2022.8.3）\r\n- [x] 新增`Jeston nano`部署文件\r\n\r\n\r\n\r\n## 环境说明\r\n\r\n- 🔥Tensorrt 8.4\r\n- 🚀Cuda 11.6.1 Cudnn 8.4.1\r\n- Opencv 4.5.1\r\n- Cmake 3.23.3\r\n- Visual Studio 2017\r\n- MX350，Windows10\r\n\r\n\r\n\r\n## 文件说明\r\n\r\n- 💼**BM、SGBM**算法均有C++和Python两个版本\r\n\r\n- 📂**tensorrt**：模型部署文件，帧率为23fps\r\n\r\n- 📁**yolov5-v6.1-pytorch-master**：未部署前的python代码文件，帧率为5fps\r\n\r\n- **stereo_introduce**：双目摄像头基本资料\r\n\r\n- 📒**双目视觉资料**：从双目相机的标定（Matlab）到sgbm生成深度图的图文教程\r\n\r\n- **stereo_shot.py**：摄像头拍摄代码\r\n\r\n- 🎁**Jeston nano_tensorrt**：Jeston nano(Linux)部署资料\r\n\r\n \r\n\r\n## 怎么用？\r\n\r\n### 双目相机的标定：https://www.bilibili.com/video/BV1GP41157Ti\r\n\r\n### SGBM算法应用(Python版)：https://www.bilibili.com/video/BV1zT411w7oZ\r\n\r\n### 在YOLOv5中加入双目测距，实现目标测距：https://www.bilibili.com/video/BV1qG41147ZW\r\n\r\n### Jeston nano部署yolov5，并实现双目测距：https://www.bilibili.com/video/BV15g411Q7ZV\r\n\r\n## 参考资料\r\n\r\n1. 🍔YOLOv5 Tensorrt Python/C++部署：https://www.bilibili.com/video/BV113411J7nk/?spm_id_from=333.788.recommend_more_video.-1&vd_source=97aec9e652524c83bb4f4b9481ee059e\r\n2. 🍞Pytorch 搭建自己的YoloV5目标检测平台Bubbliiiing：https://www.bilibili.com/video/BV1FZ4y1m777?spm_id_from=333.999.0.0\r\n3. 🍟双目摄像头-立体视觉：https://blog.csdn.net/qq_41204464/category_10766478.html?spm=1001.2014.3001.5482)\r\n4. CUDA的正确安装/升级/重装/使用方式：https://zhuanlan.zhihu.com/p/520536351\r\n5. 报错【Could not locate zlibwapi.dll. Please make sure it is in your library path】：https://blog.csdn.net/qq_44224801/article/details/125525721\r\n6. 🍿windows下 C++ openCV配置及x86编译(傻瓜式教程)：https://blog.csdn.net/qq_37059136/article/details/124165080\r\n7. 树莓派安装pytorch：https://blog.csdn.net/weixin_53798505/article/details/125235377\r\n8. 树莓派开机自启动：https://blog.csdn.net/TohkaQAQ/article/details/121056564\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n" }, { "path": "SGBM(C++)/SGBM.cpp", "content": "/* ˫Ŀ */\r\n\r\n#include \r\n#include \r\n#include \r\n\r\nusing namespace std;\r\nusing namespace cv;\r\n\r\nconst int imageWidth = 640; //ͷķֱ \r\nconst int imageHeight = 480;\r\nVec3f point3;\r\nfloat d;\r\nSize imageSize = Size(imageWidth, imageHeight);\r\n\r\nMat img;\r\nMat rgbImageL, grayImageL;\r\nMat rgbImageR, grayImageR;\r\nMat rectifyImageL, rectifyImageR;\r\nRect m_l_select;\r\nRect m_r_select;\r\n\r\nRect validROIL;//ͼУ֮󣬻ͼвüvalidROIָü֮ \r\nRect validROIR;\r\n\r\nMat mapLx, mapLy, mapRx, mapRy; //ӳ \r\nMat Rl, Rr, Pl, Pr, Q; //УתRͶӰP ͶӰQ\r\nMat xyz; //ά\r\n\r\nPoint origin; //갴µʼ\r\nRect selection; //ѡ\r\nbool selectObject = false; //Ƿѡ\r\n\r\nint blockSize = 8, mindisparity = 1, ndisparities = 64, img_channels = 3;\r\nPtr sgbm = cv::StereoSGBM::create(mindisparity, ndisparities, blockSize);\n\r\n\r\n\r\n/*ȱ궨õڲξ\r\nfx 0 cx\r\n0 fy cy\r\n0 0 1\r\n*/\r\nMat cameraMatrixL = (Mat_(3, 3) << 516.5066236, -1.444673028, 320.2950423, 0, 516.5816117, 270.7881873, 0, 0, 1.);\r\n//õĻ\r\n\r\n\r\n\r\n/*418.523322187048\t0\t0\r\n-1.26842201390676\t421.222568242056\t0\r\n344.758267538961\t243.318992284899\t1 */ //2\r\n\r\nMat distCoeffL = (Mat_(5, 1) << -0.046645194, 0.077595167, 0.012476819, -0.000711358, 0);\r\n//[0.006636837611004,0.050240447649195] [0.006681263320267,0.003130367429418]\r\n\r\n\r\n/*ȱ궨õڲξ\r\nfx 0 cx\r\n0 fy cy\r\n0 0 1\r\n*/\r\nMat cameraMatrixR = (Mat_(3, 3) << 511.8428182, 1.295112628, 317.310253, 0, 513.0748795, 269.5885026, 0, 0, 1);\r\n\r\n\r\n/*\r\n417.417985082506\t0\t0\r\n0.498638151824367\t419.795432389420\t0\r\n309.903372309072\t236.256106972796\t1\r\n*/ //2\r\n\r\n\r\nMat distCoeffR = (Mat_(5, 1) << -0.061588946, 0.122384376, 0.011081232, -0.000750439, 0);\r\n//[-0.038407383078874,0.236392800301615] [0.004121779274885,0.002296129959664]\r\n\r\n\r\n\r\nMat T = (Mat_(3, 1) << -120.3559901, -0.188953775, -0.662073075);//Tƽ\r\n//[-1.210187345641146e+02,0.519235426836325,-0.425535566316217]\r\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t //ӦMatlabT\r\n//Mat rec = (Mat_(3, 1) << -0.00306, -0.03207, 0.00206);//recתӦmatlab om \r\nMat rec = (Mat_(3, 3) << 0.999911333, -0.004351508, 0.012585312,\r\n\t0.004184066, 0.999902792, 0.013300386,\r\n\t-0.012641965, -0.013246549, 0.999832341); //recתӦmatlab om \r\n\r\n/* 0.999341122700880\t0.000660748031451783\t-0.0362888948713456\r\n-0.00206388651740061\t0.999250989651683\t-0.0386419468010579\r\n0.0362361815232777\t0.0386913826603732\t0.998593969567432 */\r\n\r\n//Mat T = (Mat_(3, 1) << -48.4, 0.241, -0.0344);//Tƽ\r\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t //[-1.210187345641146e+02,0.519235426836325,-0.425535566316217]\r\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t //ӦMatlabT\r\n\r\nMat R;//R ת\r\n\r\n\r\n\t /*****ƥ*****/\r\nvoid stereo_match(int, void*)\r\n{\r\n\t/*\r\n\tbm->setBlockSize(2 * blockSize + 5); //SADڴС5~21֮Ϊ\r\n\tbm->setROI1(validROIL);\r\n\tbm->setROI2(validROIR);\r\n\tbm->setPreFilterCap(31);\r\n\tbm->setMinDisparity(0); //СӲĬֵΪ0, Ǹֵint\r\n\tbm->setNumDisparities(numDisparities * 16 + 16);//ӲڣӲֵСӲֵ֮,ڴС16int\r\n\tbm->setTextureThreshold(10);\r\n\tbm->setUniquenessRatio(uniquenessRatio);//uniquenessRatioҪԷֹƥ\r\n\tbm->setSpeckleWindowSize(100);\r\n\tbm->setSpeckleRange(32);\r\n\tbm->setDisp12MaxDiff(-1);\r\n\t*/\r\n\n\tint P1 = 8 * img_channels * blockSize * blockSize;\n\tint P2 = 32 * img_channels * blockSize * blockSize;\n\tsgbm->setP1(P1);\n\tsgbm->setP2(P2);\n\tsgbm->setPreFilterCap(1);\n\tsgbm->setUniquenessRatio(10);\n\tsgbm->setSpeckleRange(100);\n\tsgbm->setSpeckleWindowSize(100);\n\tsgbm->setDisp12MaxDiff(-1);\n\t//sgbm->setNumDisparities(1);\n\tsgbm->setMode(cv::StereoSGBM::MODE_HH);\r\n\t\r\n\tMat disp, disp8;\r\n\tsgbm->compute(rectifyImageL, rectifyImageR, disp);//ͼΪҶͼ\r\n\tdisp8 = Mat(disp.rows, disp.cols, CV_8UC1);\r\n\tnormalize(disp, disp8, 0, 255, NORM_MINMAX, CV_8UC1);\r\n\treprojectImageTo3D(disp, xyz, Q, true); //ʵʱReprojectTo3DX / W, Y / W, Z / WҪ16(ҲW16)ܵõȷάϢ\r\n\txyz = xyz * 16;\r\n\timshow(\"disparity\", disp8);\r\n}\r\n\r\n/*****ص*****/\r\nstatic void onMouse(int event, int x, int y, int, void*)\r\n{\r\n\tif (selectObject)\r\n\t{\r\n\t\tselection.x = MIN(x, origin.x);\r\n\t\tselection.y = MIN(y, origin.y);\r\n\t\tselection.width = std::abs(x - origin.x);\r\n\t\tselection.height = std::abs(y - origin.y);\r\n\t}\r\n\r\n\tswitch (event)\r\n\t{\r\n\tcase EVENT_LBUTTONDOWN: //ťµ¼\r\n\t\torigin = Point(x, y);\r\n\t\tselection = Rect(x, y, 0, 0);\r\n\t\tselectObject = true;\r\n\t\t//cout << origin << \"in world coordinate is: \" << xyz.at(origin) << endl;\r\n\t\tpoint3 = xyz.at(origin);\r\n\t\tpoint3[0];\r\n\t\t//cout << \"point3[0]:\" << point3[0] << \"point3[1]:\" << point3[1] << \"point3[2]:\" << point3[2]< 0 && selection.height > 0)\r\n\t\t\tbreak;\r\n\t}\r\n}\r\n\r\n\r\n/**********/\r\nint main()\r\n{\r\n\t/*\r\n\tУ\r\n\t*/\r\n\tRodrigues(rec, R); //Rodrigues任\r\n\tstereoRectify(cameraMatrixL, distCoeffL, cameraMatrixR, distCoeffR, imageSize, R, T, Rl, Rr, Pl, Pr, Q, CALIB_ZERO_DISPARITY,\r\n\t\t0, imageSize, &validROIL, &validROIR);\r\n\tinitUndistortRectifyMap(cameraMatrixL, distCoeffL, Rl, Pr, imageSize, CV_32FC1, mapLx, mapLy);\r\n\tinitUndistortRectifyMap(cameraMatrixR, distCoeffR, Rr, Pr, imageSize, CV_32FC1, mapRx, mapRy);\r\n\r\n\t/*\r\n\tȡͼƬ\r\n\t*/\r\n\r\n\tm_l_select = Rect(0, 0, 640, 480);\r\n\timg = imread(\"car.jpg\", IMREAD_COLOR);\r\n\t//imshow(\"Image\", img);\r\n\trgbImageL = img(m_l_select);\r\n\tcvtColor(rgbImageL, grayImageL, COLOR_BGR2GRAY);\r\n\r\n\tm_r_select = Rect(640, 0, 640, 480);\r\n\trgbImageR = img(m_r_select);\r\n\tcvtColor(rgbImageR, grayImageR, COLOR_BGR2GRAY);\r\n\r\n\t//imshow(\"ImageL\", rgbImageL);\r\n\t//imshow(\"ImageR\", rgbImageR);\r\n\r\n\t/*\r\n\tremap֮ͼѾ沢ж׼\r\n\t*/\r\n\tremap(grayImageL, rectifyImageL, mapLx, mapLy, INTER_LINEAR);\r\n\tremap(grayImageR, rectifyImageR, mapRx, mapRy, INTER_LINEAR);\r\n\r\n\t/*\r\n\tУʾ\r\n\t*/\r\n\tMat rgbRectifyImageL, rgbRectifyImageR;\r\n\tcvtColor(rectifyImageL, rgbRectifyImageL, COLOR_GRAY2BGR); //αɫͼ\r\n\tcvtColor(rectifyImageR, rgbRectifyImageR, COLOR_GRAY2BGR);\r\n\r\n\t//ʾ\r\n\t//rectangle(rgbRectifyImageL, validROIL, Scalar(0, 0, 255), 3, 8);\r\n\t//rectangle(rgbRectifyImageR, validROIR, Scalar(0, 0, 255), 3, 8);\r\n\t//imshow(\"ImageL After Rectify\", rgbRectifyImageL);\r\n\t//imshow(\"ImageR After Rectify\", rgbRectifyImageR);\r\n\r\n\t//ʾͬһͼ\r\n\tMat canvas;\r\n\tdouble sf;\r\n\tint w, h;\r\n\tsf = 600. / MAX(imageSize.width, imageSize.height);\r\n\tw = cvRound(imageSize.width * sf);\r\n\th = cvRound(imageSize.height * sf);\r\n\tcanvas.create(h, w * 2, CV_8UC3); //עͨ\r\n\r\n\t\t\t\t\t\t\t\t\t\t//ͼ񻭵\r\n\tMat canvasPart = canvas(Rect(w * 0, 0, w, h)); //õһ \r\n\tresize(rgbRectifyImageL, canvasPart, canvasPart.size(), 0, 0, INTER_AREA); //ͼŵcanvasPartһС \r\n\tRect vroiL(cvRound(validROIL.x*sf), cvRound(validROIL.y*sf), //ñȡ \r\n\t\tcvRound(validROIL.width*sf), cvRound(validROIL.height*sf));\r\n\t//rectangle(canvasPart, vroiL, Scalar(0, 0, 255), 3, 8); //һ \r\n\tcout << \"Painted ImageL\" << endl;\r\n\r\n\t//ͼ񻭵\r\n\tcanvasPart = canvas(Rect(w, 0, w, h)); //ûһ \r\n\tresize(rgbRectifyImageR, canvasPart, canvasPart.size(), 0, 0, INTER_LINEAR);\r\n\tRect vroiR(cvRound(validROIR.x * sf), cvRound(validROIR.y*sf),\r\n\t\tcvRound(validROIR.width * sf), cvRound(validROIR.height * sf));\r\n\t//rectangle(canvasPart, vroiR, Scalar(0, 0, 255), 3, 8);\r\n\tcout << \"Painted ImageR\" << endl;\r\n\r\n\t//϶Ӧ\r\n\tfor (int i = 0; i < canvas.rows; i += 16)\r\n\t\tline(canvas, Point(0, i), Point(canvas.cols, i), Scalar(0, 255, 0), 1, 8);\r\n\timshow(\"rectified\", canvas);\r\n\r\n\t/*\r\n\tƥ\r\n\t*/\r\n\tnamedWindow(\"disparity\", WINDOW_AUTOSIZE);\r\n\r\n\t/*************************οӻ**********************************************/\r\n\t// SAD Trackbar\r\n\t//createTrackbar(\"BlockSize:\\n\", \"disparity\", &blockSize, 8, stereo_match);\r\n\t// ӲΨһ԰ٷֱȴ Trackbar\r\n\t//createTrackbar(\"UniquenessRatio:\\n\", \"disparity\", &uniquenessRatio, 50, stereo_match);\r\n\t// Ӳ Trackbar\r\n\t//createTrackbar(\"NumDisparities:\\n\", \"disparity\", &numDisparities, 16, stereo_match);\r\n\r\n\r\n\t//ӦsetMouseCallback(, ص, صIJһȡ0)\r\n\tsetMouseCallback(\"disparity\", onMouse, 0);\r\n\tstereo_match(0, 0);\r\n\r\n\twaitKey();\r\n\treturn 0;\r\n}" }, { "path": "SGBM(Python)/sgbm-video.py", "content": "import cv2\r\nimport numpy as np\r\nimport time\r\nimport random\r\nimport math\r\n\r\n# -----------------------------------双目相机的基本参数---------------------------------------------------------\r\n# left_camera_matrix 左相机的内参矩阵\r\n# right_camera_matrix 右相机的内参矩阵\r\n#\r\n# left_distortion 左相机的畸变系数 格式(K1,K2,P1,P2,0)\r\n# right_distortion 右相机的畸变系数\r\n# -------------------------------------------------------------------------------------------------------------\r\n# 左镜头的内参，如焦距\r\nleft_camera_matrix = np.array([[516.5066236,-1.444673028,320.2950423],[0,516.5816117,270.7881873],[0.,0.,1.]])\r\nright_camera_matrix = np.array([[511.8428182,1.295112628,317.310253],[0,513.0748795,269.5885026],[0.,0.,1.]])\r\n\r\n# 畸变系数,K1、K2、K3为径向畸变,P1、P2为切向畸变\r\nleft_distortion = np.array([[-0.046645194,0.077595167, 0.012476819,-0.000711358,0]])\r\nright_distortion = np.array([[-0.061588946,0.122384376,0.011081232,-0.000750439,0]])\r\n\r\n# 旋转矩阵\r\nR = np.array([[0.999911333,-0.004351508,0.012585312],\r\n [0.004184066,0.999902792,0.013300386],\r\n [-0.012641965,-0.013246549,0.999832341]])\r\n# 平移矩阵\r\nT = np.array([-120.3559901,-0.188953775,-0.662073075])\r\n\r\nsize = (640, 480)\r\n\r\nR1, R2, P1, P2, Q, validPixROI1, validPixROI2 = cv2.stereoRectify(left_camera_matrix, left_distortion,\r\n right_camera_matrix, right_distortion, size, R,\r\n T)\r\n\r\n# 校正查找映射表,将原始图像和校正后的图像上的点一一对应起来\r\nleft_map1, left_map2 = cv2.initUndistortRectifyMap(left_camera_matrix, left_distortion, R1, P1, size, cv2.CV_16SC2)\r\nright_map1, right_map2 = cv2.initUndistortRectifyMap(right_camera_matrix, right_distortion, R2, P2, size, cv2.CV_16SC2)\r\nprint(Q)\r\n\r\n# --------------------------鼠标回调函数---------------------------------------------------------\r\n# event 鼠标事件\r\n# param 输入参数\r\n# -----------------------------------------------------------------------------------------------\r\ndef onmouse_pick_points(event, x, y, flags, param):\r\n if event == cv2.EVENT_LBUTTONDOWN:\r\n threeD = param\r\n print('\\n像素坐标 x = %d, y = %d' % (x, y))\r\n # print(\"世界坐标是：\", threeD[y][x][0], threeD[y][x][1], threeD[y][x][2], \"mm\")\r\n print(\"世界坐标xyz 是：\", threeD[y][x][0] / 1000.0, threeD[y][x][1] / 1000.0, threeD[y][x][2] / 1000.0, \"m\")\r\n\r\n distance = math.sqrt(threeD[y][x][0] ** 2 + threeD[y][x][1] ** 2 + threeD[y][x][2] ** 2)\r\n distance = distance / 1000.0 # mm -> m\r\n print(\"距离是：\", distance, \"m\")\r\n\r\n\r\n# 加载视频文件\r\ncapture = cv2.VideoCapture(\"./car.avi\")\r\nWIN_NAME = 'Deep disp'\r\ncv2.namedWindow(WIN_NAME, cv2.WINDOW_AUTOSIZE)\r\n\r\n# 读取视频\r\nfps = 0.0\r\nret, frame = capture.read()\r\nwhile ret:\r\n # 开始计时\r\n t1 = time.time()\r\n # 是否读取到了帧，读取到了则为True\r\n ret, frame = capture.read()\r\n # 切割为左右两张图片\r\n frame1 = frame[0:480, 0:640]\r\n frame2 = frame[0:480, 640:1280]\r\n # 将BGR格式转换成灰度图片，用于畸变矫正\r\n imgL = cv2.cvtColor(frame1, cv2.COLOR_BGR2GRAY)\r\n imgR = cv2.cvtColor(frame2, cv2.COLOR_BGR2GRAY)\r\n\r\n # 重映射，就是把一幅图像中某位置的像素放置到另一个图片指定位置的过程。\r\n # 依据MATLAB测量数据重建无畸变图片,输入图片要求为灰度图\r\n img1_rectified = cv2.remap(imgL, left_map1, left_map2, cv2.INTER_LINEAR)\r\n img2_rectified = cv2.remap(imgR, right_map1, right_map2, cv2.INTER_LINEAR)\r\n\r\n # 转换为opencv的BGR格式\r\n imageL = cv2.cvtColor(img1_rectified, cv2.COLOR_GRAY2BGR)\r\n imageR = cv2.cvtColor(img2_rectified, cv2.COLOR_GRAY2BGR)\r\n\r\n # ------------------------------------SGBM算法----------------------------------------------------------\r\n # blockSize 深度图成块，blocksize越低，其深度图就越零碎，0 m\n\n cv2.rectangle(img,(int(temp[0]),int(temp[1])),(int(temp[0]+temp[2]),int(temp[1]+temp[3])), (0, 0, 225), 2)\n img = cv2.putText(img, str(classes[int(clas)])+\" \"+str(round(score,2))+\" dis=\"+str(round(distance,2)),\n (int(temp[0]),int(temp[1])-5), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 225), 2)\n\n return img\n\n#---------------------------------------------------#\n# 对输入图像进行不失真resize\n#---------------------------------------------------#\ndef resize_image(image, size):\n iw, ih = image.size\n w, h = size\n scale = min(w/iw, h/ih)\n nw = int(iw*scale)\n nh = int(ih*scale)\n\n image = image.resize((nw,nh), Image.BICUBIC)\n new_image = Image.new('RGB', size, (128,128,128))\n new_image.paste(image, ((w-nw)//2, (h-nh)//2))\n return new_image\n\n#----------------------加载推理所需要的engine、dll文件---------------------------------#\n# yolov5s_480 图片推理的输入格式为640x480\n# yolov5 图片推理的输入格式为640x640，若使用它，需要打开182行的resize函数\n#------------------------------------------------------------------------------------#\ndet = Detector(model_path=b\"D:\\GDEE\\Project\\Release\\yolov5s_480.engine\",dll_path=\"D:\\GDEE\\Project\\Release\\yolov5s_480.dll\") # b'' is needed\n# 加载视频文件\ncapture = cv2.VideoCapture(\"output.avi\")\nWIN_NAME = 'Deep disp'\ncv2.namedWindow(WIN_NAME, cv2.WINDOW_AUTOSIZE)\n\n# 3 读取视频\nfps = 0.0\nret, frame = capture.read()\n\nwhile ret:\n # 是否读取到了帧，读取到了则为True\n ret, frame = capture.read()\n # 开始计时，用于计算帧率\n t1 = time.time()\n img_color = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)\n frame1 = frame[0:480, 0:640]\n frame2 = frame[0:480, 640:1280] # 割开双目图像\n\n imgL = cv2.cvtColor(frame1, cv2.COLOR_BGR2GRAY) # 将BGR格式转换成灰度图片\n imgR = cv2.cvtColor(frame2, cv2.COLOR_BGR2GRAY)\n\n # cv2.remap 重映射，就是把一幅图像中某位置的像素放置到另一个图片指定位置的过程。\n # 依据MATLAB测量数据重建无畸变图片\n img1_rectified = cv2.remap(imgL, left_map1, left_map2, cv2.INTER_LINEAR)\n img2_rectified = cv2.remap(imgR, right_map1, right_map2, cv2.INTER_LINEAR)\n\n imageL = cv2.cvtColor(img1_rectified, cv2.COLOR_GRAY2BGR)\n imageR = cv2.cvtColor(img2_rectified, cv2.COLOR_GRAY2BGR)\n\n # ------------------------------------SGBM算法----------------------------------------------------------\n # blockSize 深度图成块，blocksize越低，其深度图就越零碎，0\n// SPDX-License-Identifier: MIT\n\n/****************************************************************************\\\n * Note on documentation: The source files contain links to the online *\n * documentation of the public API at https://json.nlohmann.me. This URL *\n * contains the most recent documentation and should also be applicable to *\n * previous versions; documentation for deprecated functions is not *\n * removed, but marked deprecated. See \"Generate documentation\" section in *\n * file docs/README.md. *\n\\****************************************************************************/\n\n#ifndef INCLUDE_NLOHMANN_JSON_HPP_\n#define INCLUDE_NLOHMANN_JSON_HPP_\n\n#include // all_of, find, for_each\n#include // nullptr_t, ptrdiff_t, size_t\n#include // hash, less\n#include // initializer_list\n#ifndef JSON_NO_IO\n #include // istream, ostream\n#endif // JSON_NO_IO\n#include // random_access_iterator_tag\n#include // unique_ptr\n#include // string, stoi, to_string\n#include // declval, forward, move, pair, swap\n#include // vector\n\n// #include \n// __ _____ _____ _____\n// __| | __| | | | JSON for Modern C++\n// | | |__ | | | | | | version 3.12.0\n// |_____|_____|_____|_|___| https://github.com/nlohmann/json\n//\n// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann \n// SPDX-License-Identifier: MIT\n\n\n\n#include \n\n// #include \n// __ _____ _____ _____\n// __| | __| | | | JSON for Modern C++\n// | | |__ | | | | | | version 3.12.0\n// |_____|_____|_____|_|___| https://github.com/nlohmann/json\n//\n// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann \n// SPDX-License-Identifier: MIT\n\n\n\n// This file contains all macro definitions affecting or depending on the ABI\n\n#ifndef JSON_SKIP_LIBRARY_VERSION_CHECK\n #if defined(NLOHMANN_JSON_VERSION_MAJOR) && defined(NLOHMANN_JSON_VERSION_MINOR) && defined(NLOHMANN_JSON_VERSION_PATCH)\n #if NLOHMANN_JSON_VERSION_MAJOR != 3 || NLOHMANN_JSON_VERSION_MINOR != 12 || NLOHMANN_JSON_VERSION_PATCH != 0\n #warning \"Already included a different version of the library!\"\n #endif\n #endif\n#endif\n\n#define NLOHMANN_JSON_VERSION_MAJOR 3 // NOLINT(modernize-macro-to-enum)\n#define NLOHMANN_JSON_VERSION_MINOR 12 // NOLINT(modernize-macro-to-enum)\n#define NLOHMANN_JSON_VERSION_PATCH 0 // NOLINT(modernize-macro-to-enum)\n\n#ifndef JSON_DIAGNOSTICS\n #define JSON_DIAGNOSTICS 0\n#endif\n\n#ifndef JSON_DIAGNOSTIC_POSITIONS\n #define JSON_DIAGNOSTIC_POSITIONS 0\n#endif\n\n#ifndef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON\n #define JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON 0\n#endif\n\n#if JSON_DIAGNOSTICS\n #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS _diag\n#else\n #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS\n#endif\n\n#if JSON_DIAGNOSTIC_POSITIONS\n #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTIC_POSITIONS _dp\n#else\n #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTIC_POSITIONS\n#endif\n\n#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON\n #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON _ldvcmp\n#else\n #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON\n#endif\n\n#ifndef NLOHMANN_JSON_NAMESPACE_NO_VERSION\n #define NLOHMANN_JSON_NAMESPACE_NO_VERSION 0\n#endif\n\n// Construct the namespace ABI tags component\n#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c) json_abi ## a ## b ## c\n#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c) \\\n NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c)\n\n#define NLOHMANN_JSON_ABI_TAGS \\\n NLOHMANN_JSON_ABI_TAGS_CONCAT( \\\n NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS, \\\n NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON, \\\n NLOHMANN_JSON_ABI_TAG_DIAGNOSTIC_POSITIONS)\n\n// Construct the namespace version component\n#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \\\n _v ## major ## _ ## minor ## _ ## patch\n#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(major, minor, patch) \\\n NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch)\n\n#if NLOHMANN_JSON_NAMESPACE_NO_VERSION\n#define NLOHMANN_JSON_NAMESPACE_VERSION\n#else\n#define NLOHMANN_JSON_NAMESPACE_VERSION \\\n NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(NLOHMANN_JSON_VERSION_MAJOR, \\\n NLOHMANN_JSON_VERSION_MINOR, \\\n NLOHMANN_JSON_VERSION_PATCH)\n#endif\n\n// Combine namespace components\n#define NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b) a ## b\n#define NLOHMANN_JSON_NAMESPACE_CONCAT(a, b) \\\n NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b)\n\n#ifndef NLOHMANN_JSON_NAMESPACE\n#define NLOHMANN_JSON_NAMESPACE \\\n nlohmann::NLOHMANN_JSON_NAMESPACE_CONCAT( \\\n NLOHMANN_JSON_ABI_TAGS, \\\n NLOHMANN_JSON_NAMESPACE_VERSION)\n#endif\n\n#ifndef NLOHMANN_JSON_NAMESPACE_BEGIN\n#define NLOHMANN_JSON_NAMESPACE_BEGIN \\\n namespace nlohmann \\\n { \\\n inline namespace NLOHMANN_JSON_NAMESPACE_CONCAT( \\\n NLOHMANN_JSON_ABI_TAGS, \\\n NLOHMANN_JSON_NAMESPACE_VERSION) \\\n {\n#endif\n\n#ifndef NLOHMANN_JSON_NAMESPACE_END\n#define NLOHMANN_JSON_NAMESPACE_END \\\n } /* namespace (inline namespace) NOLINT(readability/namespace) */ \\\n } // namespace nlohmann\n#endif\n\n// #include \n// __ _____ _____ _____\n// __| | __| | | | JSON for Modern C++\n// | | |__ | | | | | | version 3.12.0\n// |_____|_____|_____|_|___| https://github.com/nlohmann/json\n//\n// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann \n// SPDX-License-Identifier: MIT\n\n\n\n#include // transform\n#include // array\n#include // forward_list\n#include // inserter, front_inserter, end\n#include // map\n#ifdef JSON_HAS_CPP_17\n #include // optional\n#endif\n#include // string\n#include // tuple, make_tuple\n#include // is_arithmetic, is_same, is_enum, underlying_type, is_convertible\n#include // unordered_map\n#include // pair, declval\n#include // valarray\n\n// #include \n// __ _____ _____ _____\n// __| | __| | | | JSON for Modern C++\n// | | |__ | | | | | | version 3.12.0\n// |_____|_____|_____|_|___| https://github.com/nlohmann/json\n//\n// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann \n// SPDX-License-Identifier: MIT\n\n\n\n#include // nullptr_t\n#include // exception\n#if JSON_DIAGNOSTICS\n #include // accumulate\n#endif\n#include // runtime_error\n#include // to_string\n#include // vector\n\n// #include \n// __ _____ _____ _____\n// __| | __| | | | JSON for Modern C++\n// | | |__ | | | | | | version 3.12.0\n// |_____|_____|_____|_|___| https://github.com/nlohmann/json\n//\n// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann \n// SPDX-License-Identifier: MIT\n\n\n\n#include // array\n#include // size_t\n#include // uint8_t\n#include // string\n\n// #include \n// __ _____ _____ _____\n// __| | __| | | | JSON for Modern C++\n// | | |__ | | | | | | version 3.12.0\n// |_____|_____|_____|_|___| https://github.com/nlohmann/json\n//\n// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann \n// SPDX-License-Identifier: MIT\n\n\n\n#include // declval, pair\n// #include \n// __ _____ _____ _____\n// __| | __| | | | JSON for Modern C++\n// | | |__ | | | | | | version 3.12.0\n// |_____|_____|_____|_|___| https://github.com/nlohmann/json\n//\n// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann \n// SPDX-License-Identifier: MIT\n\n\n\n#include \n\n// #include \n// __ _____ _____ _____\n// __| | __| | | | JSON for Modern C++\n// | | |__ | | | | | | version 3.12.0\n// |_____|_____|_____|_|___| https://github.com/nlohmann/json\n//\n// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann \n// SPDX-License-Identifier: MIT\n\n\n\n// #include \n\n\nNLOHMANN_JSON_NAMESPACE_BEGIN\nnamespace detail\n{\n\ntemplate struct make_void\n{\n using type = void;\n};\ntemplate using void_t = typename make_void::type;\n\n} // namespace detail\nNLOHMANN_JSON_NAMESPACE_END\n\n\nNLOHMANN_JSON_NAMESPACE_BEGIN\nnamespace detail\n{\n\n// https://en.cppreference.com/w/cpp/experimental/is_detected\nstruct nonesuch\n{\n nonesuch() = delete;\n ~nonesuch() = delete;\n nonesuch(nonesuch const&) = delete;\n nonesuch(nonesuch const&&) = delete;\n void operator=(nonesuch const&) = delete;\n void operator=(nonesuch&&) = delete;\n};\n\ntemplate class Op,\n class... Args>\nstruct detector\n{\n using value_t = std::false_type;\n using type = Default;\n};\n\ntemplate class Op, class... Args>\nstruct detector>, Op, Args...>\n{\n using value_t = std::true_type;\n using type = Op;\n};\n\ntemplate class Op, class... Args>\nusing is_detected = typename detector::value_t;\n\ntemplate class Op, class... Args>\nstruct is_detected_lazy : is_detected { };\n\ntemplate class Op, class... Args>\nusing detected_t = typename detector::type;\n\ntemplate class Op, class... Args>\nusing detected_or = detector;\n\ntemplate class Op, class... Args>\nusing detected_or_t = typename detected_or::type;\n\ntemplate class Op, class... Args>\nusing is_detected_exact = std::is_same>;\n\ntemplate class Op, class... Args>\nusing is_detected_convertible =\n std::is_convertible, To>;\n\n} // namespace detail\nNLOHMANN_JSON_NAMESPACE_END\n\n// #include \n\n\n// __ _____ _____ _____\n// __| | __| | | | JSON for Modern C++\n// | | |__ | | | | | | version 3.12.0\n// |_____|_____|_____|_|___| https://github.com/nlohmann/json\n//\n// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann \n// SPDX-FileCopyrightText: 2016 - 2021 Evan Nemerson \n// SPDX-License-Identifier: MIT\n\n/* Hedley - https://nemequ.github.io/hedley\n * Created by Evan Nemerson \n */\n\n#if !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < 15)\n#if defined(JSON_HEDLEY_VERSION)\n #undef JSON_HEDLEY_VERSION\n#endif\n#define JSON_HEDLEY_VERSION 15\n\n#if defined(JSON_HEDLEY_STRINGIFY_EX)\n #undef JSON_HEDLEY_STRINGIFY_EX\n#endif\n#define JSON_HEDLEY_STRINGIFY_EX(x) #x\n\n#if defined(JSON_HEDLEY_STRINGIFY)\n #undef JSON_HEDLEY_STRINGIFY\n#endif\n#define JSON_HEDLEY_STRINGIFY(x) JSON_HEDLEY_STRINGIFY_EX(x)\n\n#if defined(JSON_HEDLEY_CONCAT_EX)\n #undef JSON_HEDLEY_CONCAT_EX\n#endif\n#define JSON_HEDLEY_CONCAT_EX(a,b) a##b\n\n#if defined(JSON_HEDLEY_CONCAT)\n #undef JSON_HEDLEY_CONCAT\n#endif\n#define JSON_HEDLEY_CONCAT(a,b) JSON_HEDLEY_CONCAT_EX(a,b)\n\n#if defined(JSON_HEDLEY_CONCAT3_EX)\n #undef JSON_HEDLEY_CONCAT3_EX\n#endif\n#define JSON_HEDLEY_CONCAT3_EX(a,b,c) a##b##c\n\n#if defined(JSON_HEDLEY_CONCAT3)\n #undef JSON_HEDLEY_CONCAT3\n#endif\n#define JSON_HEDLEY_CONCAT3(a,b,c) JSON_HEDLEY_CONCAT3_EX(a,b,c)\n\n#if defined(JSON_HEDLEY_VERSION_ENCODE)\n #undef JSON_HEDLEY_VERSION_ENCODE\n#endif\n#define JSON_HEDLEY_VERSION_ENCODE(major,minor,revision) (((major) * 1000000) + ((minor) * 1000) + (revision))\n\n#if defined(JSON_HEDLEY_VERSION_DECODE_MAJOR)\n #undef JSON_HEDLEY_VERSION_DECODE_MAJOR\n#endif\n#define JSON_HEDLEY_VERSION_DECODE_MAJOR(version) ((version) / 1000000)\n\n#if defined(JSON_HEDLEY_VERSION_DECODE_MINOR)\n #undef JSON_HEDLEY_VERSION_DECODE_MINOR\n#endif\n#define JSON_HEDLEY_VERSION_DECODE_MINOR(version) (((version) % 1000000) / 1000)\n\n#if defined(JSON_HEDLEY_VERSION_DECODE_REVISION)\n #undef JSON_HEDLEY_VERSION_DECODE_REVISION\n#endif\n#define JSON_HEDLEY_VERSION_DECODE_REVISION(version) ((version) % 1000)\n\n#if defined(JSON_HEDLEY_GNUC_VERSION)\n #undef JSON_HEDLEY_GNUC_VERSION\n#endif\n#if defined(__GNUC__) && defined(__GNUC_PATCHLEVEL__)\n #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)\n#elif defined(__GNUC__)\n #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, 0)\n#endif\n\n#if defined(JSON_HEDLEY_GNUC_VERSION_CHECK)\n #undef JSON_HEDLEY_GNUC_VERSION_CHECK\n#endif\n#if defined(JSON_HEDLEY_GNUC_VERSION)\n #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GNUC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))\n#else\n #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (0)\n#endif\n\n#if defined(JSON_HEDLEY_MSVC_VERSION)\n #undef JSON_HEDLEY_MSVC_VERSION\n#endif\n#if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 140000000) && !defined(__ICL)\n #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 10000000, (_MSC_FULL_VER % 10000000) / 100000, (_MSC_FULL_VER % 100000) / 100)\n#elif defined(_MSC_FULL_VER) && !defined(__ICL)\n #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 1000000, (_MSC_FULL_VER % 1000000) / 10000, (_MSC_FULL_VER % 10000) / 10)\n#elif defined(_MSC_VER) && !defined(__ICL)\n #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_VER / 100, _MSC_VER % 100, 0)\n#endif\n\n#if defined(JSON_HEDLEY_MSVC_VERSION_CHECK)\n #undef JSON_HEDLEY_MSVC_VERSION_CHECK\n#endif\n#if !defined(JSON_HEDLEY_MSVC_VERSION)\n #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (0)\n#elif defined(_MSC_VER) && (_MSC_VER >= 1400)\n #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 10000000) + (minor * 100000) + (patch)))\n#elif defined(_MSC_VER) && (_MSC_VER >= 1200)\n #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 1000000) + (minor * 10000) + (patch)))\n#else\n #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_VER >= ((major * 100) + (minor)))\n#endif\n\n#if defined(JSON_HEDLEY_INTEL_VERSION)\n #undef JSON_HEDLEY_INTEL_VERSION\n#endif\n#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && !defined(__ICL)\n #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, __INTEL_COMPILER_UPDATE)\n#elif defined(__INTEL_COMPILER) && !defined(__ICL)\n #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, 0)\n#endif\n\n#if defined(JSON_HEDLEY_INTEL_VERSION_CHECK)\n #undef JSON_HEDLEY_INTEL_VERSION_CHECK\n#endif\n#if defined(JSON_HEDLEY_INTEL_VERSION)\n #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))\n#else\n #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (0)\n#endif\n\n#if defined(JSON_HEDLEY_INTEL_CL_VERSION)\n #undef JSON_HEDLEY_INTEL_CL_VERSION\n#endif\n#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && defined(__ICL)\n #define JSON_HEDLEY_INTEL_CL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER, __INTEL_COMPILER_UPDATE, 0)\n#endif\n\n#if defined(JSON_HEDLEY_INTEL_CL_VERSION_CHECK)\n #undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK\n#endif\n#if defined(JSON_HEDLEY_INTEL_CL_VERSION)\n #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_CL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))\n#else\n #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (0)\n#endif\n\n#if defined(JSON_HEDLEY_PGI_VERSION)\n #undef JSON_HEDLEY_PGI_VERSION\n#endif\n#if defined(__PGI) && defined(__PGIC__) && defined(__PGIC_MINOR__) && defined(__PGIC_PATCHLEVEL__)\n #define JSON_HEDLEY_PGI_VERSION JSON_HEDLEY_VERSION_ENCODE(__PGIC__, __PGIC_MINOR__, __PGIC_PATCHLEVEL__)\n#endif\n\n#if defined(JSON_HEDLEY_PGI_VERSION_CHECK)\n #undef JSON_HEDLEY_PGI_VERSION_CHECK\n#endif\n#if defined(JSON_HEDLEY_PGI_VERSION)\n #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PGI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))\n#else\n #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (0)\n#endif\n\n#if defined(JSON_HEDLEY_SUNPRO_VERSION)\n #undef JSON_HEDLEY_SUNPRO_VERSION\n#endif\n#if defined(__SUNPRO_C) && (__SUNPRO_C > 0x1000)\n #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_C >> 16) & 0xf) * 10) + ((__SUNPRO_C >> 12) & 0xf), (((__SUNPRO_C >> 8) & 0xf) * 10) + ((__SUNPRO_C >> 4) & 0xf), (__SUNPRO_C & 0xf) * 10)\n#elif defined(__SUNPRO_C)\n #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_C >> 8) & 0xf, (__SUNPRO_C >> 4) & 0xf, (__SUNPRO_C) & 0xf)\n#elif defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x1000)\n #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_CC >> 16) & 0xf) * 10) + ((__SUNPRO_CC >> 12) & 0xf), (((__SUNPRO_CC >> 8) & 0xf) * 10) + ((__SUNPRO_CC >> 4) & 0xf), (__SUNPRO_CC & 0xf) * 10)\n#elif defined(__SUNPRO_CC)\n #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_CC >> 8) & 0xf, (__SUNPRO_CC >> 4) & 0xf, (__SUNPRO_CC) & 0xf)\n#endif\n\n#if defined(JSON_HEDLEY_SUNPRO_VERSION_CHECK)\n #undef JSON_HEDLEY_SUNPRO_VERSION_CHECK\n#endif\n#if defined(JSON_HEDLEY_SUNPRO_VERSION)\n #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_SUNPRO_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))\n#else\n #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (0)\n#endif\n\n#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)\n #undef JSON_HEDLEY_EMSCRIPTEN_VERSION\n#endif\n#if defined(__EMSCRIPTEN__)\n #define JSON_HEDLEY_EMSCRIPTEN_VERSION JSON_HEDLEY_VERSION_ENCODE(__EMSCRIPTEN_major__, __EMSCRIPTEN_minor__, __EMSCRIPTEN_tiny__)\n#endif\n\n#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK)\n #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK\n#endif\n#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)\n #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_EMSCRIPTEN_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))\n#else\n #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (0)\n#endif\n\n#if defined(JSON_HEDLEY_ARM_VERSION)\n #undef JSON_HEDLEY_ARM_VERSION\n#endif\n#if defined(__CC_ARM) && defined(__ARMCOMPILER_VERSION)\n #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCOMPILER_VERSION / 1000000, (__ARMCOMPILER_VERSION % 1000000) / 10000, (__ARMCOMPILER_VERSION % 10000) / 100)\n#elif defined(__CC_ARM) && defined(__ARMCC_VERSION)\n #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCC_VERSION / 1000000, (__ARMCC_VERSION % 1000000) / 10000, (__ARMCC_VERSION % 10000) / 100)\n#endif\n\n#if defined(JSON_HEDLEY_ARM_VERSION_CHECK)\n #undef JSON_HEDLEY_ARM_VERSION_CHECK\n#endif\n#if defined(JSON_HEDLEY_ARM_VERSION)\n #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_ARM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))\n#else\n #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (0)\n#endif\n\n#if defined(JSON_HEDLEY_IBM_VERSION)\n #undef JSON_HEDLEY_IBM_VERSION\n#endif\n#if defined(__ibmxl__)\n #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ibmxl_version__, __ibmxl_release__, __ibmxl_modification__)\n#elif defined(__xlC__) && defined(__xlC_ver__)\n #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, (__xlC_ver__ >> 8) & 0xff)\n#elif defined(__xlC__)\n #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, 0)\n#endif\n\n#if defined(JSON_HEDLEY_IBM_VERSION_CHECK)\n #undef JSON_HEDLEY_IBM_VERSION_CHECK\n#endif\n#if defined(JSON_HEDLEY_IBM_VERSION)\n #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IBM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))\n#else\n #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (0)\n#endif\n\n#if defined(JSON_HEDLEY_TI_VERSION)\n #undef JSON_HEDLEY_TI_VERSION\n#endif\n#if \\\n defined(__TI_COMPILER_VERSION__) && \\\n ( \\\n defined(__TMS470__) || defined(__TI_ARM__) || \\\n defined(__MSP430__) || \\\n defined(__TMS320C2000__) \\\n )\n#if (__TI_COMPILER_VERSION__ >= 16000000)\n #define JSON_HEDLEY_TI_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))\n#endif\n#endif\n\n#if defined(JSON_HEDLEY_TI_VERSION_CHECK)\n #undef JSON_HEDLEY_TI_VERSION_CHECK\n#endif\n#if defined(JSON_HEDLEY_TI_VERSION)\n #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))\n#else\n #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (0)\n#endif\n\n#if defined(JSON_HEDLEY_TI_CL2000_VERSION)\n #undef JSON_HEDLEY_TI_CL2000_VERSION\n#endif\n#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C2000__)\n #define JSON_HEDLEY_TI_CL2000_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))\n#endif\n\n#if defined(JSON_HEDLEY_TI_CL2000_VERSION_CHECK)\n #undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK\n#endif\n#if defined(JSON_HEDLEY_TI_CL2000_VERSION)\n #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL2000_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))\n#else\n #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (0)\n#endif\n\n#if defined(JSON_HEDLEY_TI_CL430_VERSION)\n #undef JSON_HEDLEY_TI_CL430_VERSION\n#endif\n#if defined(__TI_COMPILER_VERSION__) && defined(__MSP430__)\n #define JSON_HEDLEY_TI_CL430_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))\n#endif\n\n#if defined(JSON_HEDLEY_TI_CL430_VERSION_CHECK)\n #undef JSON_HEDLEY_TI_CL430_VERSION_CHECK\n#endif\n#if defined(JSON_HEDLEY_TI_CL430_VERSION)\n #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL430_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))\n#else\n #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (0)\n#endif\n\n#if defined(JSON_HEDLEY_TI_ARMCL_VERSION)\n #undef JSON_HEDLEY_TI_ARMCL_VERSION\n#endif\n#if defined(__TI_COMPILER_VERSION__) && (defined(__TMS470__) || defined(__TI_ARM__))\n #define JSON_HEDLEY_TI_ARMCL_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))\n#endif\n\n#if defined(JSON_HEDLEY_TI_ARMCL_VERSION_CHECK)\n #undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK\n#endif\n#if defined(JSON_HEDLEY_TI_ARMCL_VERSION)\n #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_ARMCL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))\n#else\n #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (0)\n#endif\n\n#if defined(JSON_HEDLEY_TI_CL6X_VERSION)\n #undef JSON_HEDLEY_TI_CL6X_VERSION\n#endif\n#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C6X__)\n #define JSON_HEDLEY_TI_CL6X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))\n#endif\n\n#if defined(JSON_HEDLEY_TI_CL6X_VERSION_CHECK)\n #undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK\n#endif\n#if defined(JSON_HEDLEY_TI_CL6X_VERSION)\n #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL6X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))\n#else\n #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (0)\n#endif\n\n#if defined(JSON_HEDLEY_TI_CL7X_VERSION)\n #undef JSON_HEDLEY_TI_CL7X_VERSION\n#endif\n#if defined(__TI_COMPILER_VERSION__) && defined(__C7000__)\n #define JSON_HEDLEY_TI_CL7X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))\n#endif\n\n#if defined(JSON_HEDLEY_TI_CL7X_VERSION_CHECK)\n #undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK\n#endif\n#if defined(JSON_HEDLEY_TI_CL7X_VERSION)\n #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL7X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))\n#else\n #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (0)\n#endif\n\n#if defined(JSON_HEDLEY_TI_CLPRU_VERSION)\n #undef JSON_HEDLEY_TI_CLPRU_VERSION\n#endif\n#if defined(__TI_COMPILER_VERSION__) && defined(__PRU__)\n #define JSON_HEDLEY_TI_CLPRU_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))\n#endif\n\n#if defined(JSON_HEDLEY_TI_CLPRU_VERSION_CHECK)\n #undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK\n#endif\n#if defined(JSON_HEDLEY_TI_CLPRU_VERSION)\n #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CLPRU_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))\n#else\n #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (0)\n#endif\n\n#if defined(JSON_HEDLEY_CRAY_VERSION)\n #undef JSON_HEDLEY_CRAY_VERSION\n#endif\n#if defined(_CRAYC)\n #if defined(_RELEASE_PATCHLEVEL)\n #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, _RELEASE_PATCHLEVEL)\n #else\n #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, 0)\n #endif\n#endif\n\n#if defined(JSON_HEDLEY_CRAY_VERSION_CHECK)\n #undef JSON_HEDLEY_CRAY_VERSION_CHECK\n#endif\n#if defined(JSON_HEDLEY_CRAY_VERSION)\n #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_CRAY_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))\n#else\n #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (0)\n#endif\n\n#if defined(JSON_HEDLEY_IAR_VERSION)\n #undef JSON_HEDLEY_IAR_VERSION\n#endif\n#if defined(__IAR_SYSTEMS_ICC__)\n #if __VER__ > 1000\n #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE((__VER__ / 1000000), ((__VER__ / 1000) % 1000), (__VER__ % 1000))\n #else\n #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE(__VER__ / 100, __VER__ % 100, 0)\n #endif\n#endif\n\n#if defined(JSON_HEDLEY_IAR_VERSION_CHECK)\n #undef JSON_HEDLEY_IAR_VERSION_CHECK\n#endif\n#if defined(JSON_HEDLEY_IAR_VERSION)\n #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IAR_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))\n#else\n #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (0)\n#endif\n\n#if defined(JSON_HEDLEY_TINYC_VERSION)\n #undef JSON_HEDLEY_TINYC_VERSION\n#endif\n#if defined(__TINYC__)\n #define JSON_HEDLEY_TINYC_VERSION JSON_HEDLEY_VERSION_ENCODE(__TINYC__ / 1000, (__TINYC__ / 100) % 10, __TINYC__ % 100)\n#endif\n\n#if defined(JSON_HEDLEY_TINYC_VERSION_CHECK)\n #undef JSON_HEDLEY_TINYC_VERSION_CHECK\n#endif\n#if defined(JSON_HEDLEY_TINYC_VERSION)\n #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TINYC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))\n#else\n #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (0)\n#endif\n\n#if defined(JSON_HEDLEY_DMC_VERSION)\n #undef JSON_HEDLEY_DMC_VERSION\n#endif\n#if defined(__DMC__)\n #define JSON_HEDLEY_DMC_VERSION JSON_HEDLEY_VERSION_ENCODE(__DMC__ >> 8, (__DMC__ >> 4) & 0xf, __DMC__ & 0xf)\n#endif\n\n#if defined(JSON_HEDLEY_DMC_VERSION_CHECK)\n #undef JSON_HEDLEY_DMC_VERSION_CHECK\n#endif\n#if defined(JSON_HEDLEY_DMC_VERSION)\n #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_DMC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))\n#else\n #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (0)\n#endif\n\n#if defined(JSON_HEDLEY_COMPCERT_VERSION)\n #undef JSON_HEDLEY_COMPCERT_VERSION\n#endif\n#if defined(__COMPCERT_VERSION__)\n #define JSON_HEDLEY_COMPCERT_VERSION JSON_HEDLEY_VERSION_ENCODE(__COMPCERT_VERSION__ / 10000, (__COMPCERT_VERSION__ / 100) % 100, __COMPCERT_VERSION__ % 100)\n#endif\n\n#if defined(JSON_HEDLEY_COMPCERT_VERSION_CHECK)\n #undef JSON_HEDLEY_COMPCERT_VERSION_CHECK\n#endif\n#if defined(JSON_HEDLEY_COMPCERT_VERSION)\n #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_COMPCERT_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))\n#else\n #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (0)\n#endif\n\n#if defined(JSON_HEDLEY_PELLES_VERSION)\n #undef JSON_HEDLEY_PELLES_VERSION\n#endif\n#if defined(__POCC__)\n #define JSON_HEDLEY_PELLES_VERSION JSON_HEDLEY_VERSION_ENCODE(__POCC__ / 100, __POCC__ % 100, 0)\n#endif\n\n#if defined(JSON_HEDLEY_PELLES_VERSION_CHECK)\n #undef JSON_HEDLEY_PELLES_VERSION_CHECK\n#endif\n#if defined(JSON_HEDLEY_PELLES_VERSION)\n #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PELLES_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))\n#else\n #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (0)\n#endif\n\n#if defined(JSON_HEDLEY_MCST_LCC_VERSION)\n #undef JSON_HEDLEY_MCST_LCC_VERSION\n#endif\n#if defined(__LCC__) && defined(__LCC_MINOR__)\n #define JSON_HEDLEY_MCST_LCC_VERSION JSON_HEDLEY_VERSION_ENCODE(__LCC__ / 100, __LCC__ % 100, __LCC_MINOR__)\n#endif\n\n#if defined(JSON_HEDLEY_MCST_LCC_VERSION_CHECK)\n #undef JSON_HEDLEY_MCST_LCC_VERSION_CHECK\n#endif\n#if defined(JSON_HEDLEY_MCST_LCC_VERSION)\n #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_MCST_LCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))\n#else\n #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (0)\n#endif\n\n#if defined(JSON_HEDLEY_GCC_VERSION)\n #undef JSON_HEDLEY_GCC_VERSION\n#endif\n#if \\\n defined(JSON_HEDLEY_GNUC_VERSION) && \\\n !defined(__clang__) && \\\n !defined(JSON_HEDLEY_INTEL_VERSION) && \\\n !defined(JSON_HEDLEY_PGI_VERSION) && \\\n !defined(JSON_HEDLEY_ARM_VERSION) && \\\n !defined(JSON_HEDLEY_CRAY_VERSION) && \\\n !defined(JSON_HEDLEY_TI_VERSION) && \\\n !defined(JSON_HEDLEY_TI_ARMCL_VERSION) && \\\n !defined(JSON_HEDLEY_TI_CL430_VERSION) && \\\n !defined(JSON_HEDLEY_TI_CL2000_VERSION) && \\\n !defined(JSON_HEDLEY_TI_CL6X_VERSION) && \\\n !defined(JSON_HEDLEY_TI_CL7X_VERSION) && \\\n !defined(JSON_HEDLEY_TI_CLPRU_VERSION) && \\\n !defined(__COMPCERT__) && \\\n !defined(JSON_HEDLEY_MCST_LCC_VERSION)\n #define JSON_HEDLEY_GCC_VERSION JSON_HEDLEY_GNUC_VERSION\n#endif\n\n#if defined(JSON_HEDLEY_GCC_VERSION_CHECK)\n #undef JSON_HEDLEY_GCC_VERSION_CHECK\n#endif\n#if defined(JSON_HEDLEY_GCC_VERSION)\n #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))\n#else\n #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (0)\n#endif\n\n#if defined(JSON_HEDLEY_HAS_ATTRIBUTE)\n #undef JSON_HEDLEY_HAS_ATTRIBUTE\n#endif\n#if \\\n defined(__has_attribute) && \\\n ( \\\n (!defined(JSON_HEDLEY_IAR_VERSION) || JSON_HEDLEY_IAR_VERSION_CHECK(8,5,9)) \\\n )\n# define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) __has_attribute(attribute)\n#else\n# define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) (0)\n#endif\n\n#if defined(JSON_HEDLEY_GNUC_HAS_ATTRIBUTE)\n #undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE\n#endif\n#if defined(__has_attribute)\n #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)\n#else\n #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)\n#endif\n\n#if defined(JSON_HEDLEY_GCC_HAS_ATTRIBUTE)\n #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE\n#endif\n#if defined(__has_attribute)\n #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)\n#else\n #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)\n#endif\n\n#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE)\n #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE\n#endif\n#if \\\n defined(__has_cpp_attribute) && \\\n defined(__cplusplus) && \\\n (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0))\n #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) __has_cpp_attribute(attribute)\n#else\n #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) (0)\n#endif\n\n#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS)\n #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS\n#endif\n#if !defined(__cplusplus) || !defined(__has_cpp_attribute)\n #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)\n#elif \\\n !defined(JSON_HEDLEY_PGI_VERSION) && \\\n !defined(JSON_HEDLEY_IAR_VERSION) && \\\n (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) && \\\n (!defined(JSON_HEDLEY_MSVC_VERSION) || JSON_HEDLEY_MSVC_VERSION_CHECK(19,20,0))\n #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(ns::attribute)\n#else\n #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)\n#endif\n\n#if defined(JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE)\n #undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE\n#endif\n#if defined(__has_cpp_attribute) && defined(__cplusplus)\n #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)\n#else\n #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)\n#endif\n\n#if defined(JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE)\n #undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE\n#endif\n#if defined(__has_cpp_attribute) && defined(__cplusplus)\n #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)\n#else\n #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)\n#endif\n\n#if defined(JSON_HEDLEY_HAS_BUILTIN)\n #undef JSON_HEDLEY_HAS_BUILTIN\n#endif\n#if defined(__has_builtin)\n #define JSON_HEDLEY_HAS_BUILTIN(builtin) __has_builtin(builtin)\n#else\n #define JSON_HEDLEY_HAS_BUILTIN(builtin) (0)\n#endif\n\n#if defined(JSON_HEDLEY_GNUC_HAS_BUILTIN)\n #undef JSON_HEDLEY_GNUC_HAS_BUILTIN\n#endif\n#if defined(__has_builtin)\n #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)\n#else\n #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)\n#endif\n\n#if defined(JSON_HEDLEY_GCC_HAS_BUILTIN)\n #undef JSON_HEDLEY_GCC_HAS_BUILTIN\n#endif\n#if defined(__has_builtin)\n #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)\n#else\n #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)\n#endif\n\n#if defined(JSON_HEDLEY_HAS_FEATURE)\n #undef JSON_HEDLEY_HAS_FEATURE\n#endif\n#if defined(__has_feature)\n #define JSON_HEDLEY_HAS_FEATURE(feature) __has_feature(feature)\n#else\n #define JSON_HEDLEY_HAS_FEATURE(feature) (0)\n#endif\n\n#if defined(JSON_HEDLEY_GNUC_HAS_FEATURE)\n #undef JSON_HEDLEY_GNUC_HAS_FEATURE\n#endif\n#if defined(__has_feature)\n #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)\n#else\n #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)\n#endif\n\n#if defined(JSON_HEDLEY_GCC_HAS_FEATURE)\n #undef JSON_HEDLEY_GCC_HAS_FEATURE\n#endif\n#if defined(__has_feature)\n #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)\n#else\n #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)\n#endif\n\n#if defined(JSON_HEDLEY_HAS_EXTENSION)\n #undef JSON_HEDLEY_HAS_EXTENSION\n#endif\n#if defined(__has_extension)\n #define JSON_HEDLEY_HAS_EXTENSION(extension) __has_extension(extension)\n#else\n #define JSON_HEDLEY_HAS_EXTENSION(extension) (0)\n#endif\n\n#if defined(JSON_HEDLEY_GNUC_HAS_EXTENSION)\n #undef JSON_HEDLEY_GNUC_HAS_EXTENSION\n#endif\n#if defined(__has_extension)\n #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)\n#else\n #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)\n#endif\n\n#if defined(JSON_HEDLEY_GCC_HAS_EXTENSION)\n #undef JSON_HEDLEY_GCC_HAS_EXTENSION\n#endif\n#if defined(__has_extension)\n #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)\n#else\n #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)\n#endif\n\n#if defined(JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE)\n #undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE\n#endif\n#if defined(__has_declspec_attribute)\n #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) __has_declspec_attribute(attribute)\n#else\n #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) (0)\n#endif\n\n#if defined(JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE)\n #undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE\n#endif\n#if defined(__has_declspec_attribute)\n #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)\n#else\n #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)\n#endif\n\n#if defined(JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE)\n #undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE\n#endif\n#if defined(__has_declspec_attribute)\n #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)\n#else\n #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)\n#endif\n\n#if defined(JSON_HEDLEY_HAS_WARNING)\n #undef JSON_HEDLEY_HAS_WARNING\n#endif\n#if defined(__has_warning)\n #define JSON_HEDLEY_HAS_WARNING(warning) __has_warning(warning)\n#else\n #define JSON_HEDLEY_HAS_WARNING(warning) (0)\n#endif\n\n#if defined(JSON_HEDLEY_GNUC_HAS_WARNING)\n #undef JSON_HEDLEY_GNUC_HAS_WARNING\n#endif\n#if defined(__has_warning)\n #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)\n#else\n #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)\n#endif\n\n#if defined(JSON_HEDLEY_GCC_HAS_WARNING)\n #undef JSON_HEDLEY_GCC_HAS_WARNING\n#endif\n#if defined(__has_warning)\n #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)\n#else\n #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)\n#endif\n\n#if \\\n (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \\\n defined(__clang__) || \\\n JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \\\n JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \\\n JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \\\n JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \\\n JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \\\n JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \\\n JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \\\n JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \\\n JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \\\n JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,0,0) || \\\n JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \\\n JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \\\n JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) || \\\n JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,17) || \\\n JSON_HEDLEY_SUNPRO_VERSION_CHECK(8,0,0) || \\\n (JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) && defined(__C99_PRAGMA_OPERATOR))\n #define JSON_HEDLEY_PRAGMA(value) _Pragma(#value)\n#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)\n #define JSON_HEDLEY_PRAGMA(value) __pragma(value)\n#else\n #define JSON_HEDLEY_PRAGMA(value)\n#endif\n\n#if defined(JSON_HEDLEY_DIAGNOSTIC_PUSH)\n #undef JSON_HEDLEY_DIAGNOSTIC_PUSH\n#endif\n#if defined(JSON_HEDLEY_DIAGNOSTIC_POP)\n #undef JSON_HEDLEY_DIAGNOSTIC_POP\n#endif\n#if defined(__clang__)\n #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma(\"clang diagnostic push\")\n #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma(\"clang diagnostic pop\")\n#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)\n #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma(\"warning(push)\")\n #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma(\"warning(pop)\")\n#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)\n #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma(\"GCC diagnostic push\")\n #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma(\"GCC diagnostic pop\")\n#elif \\\n JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \\\n JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)\n #define JSON_HEDLEY_DIAGNOSTIC_PUSH __pragma(warning(push))\n #define JSON_HEDLEY_DIAGNOSTIC_POP __pragma(warning(pop))\n#elif JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0)\n #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma(\"push\")\n #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma(\"pop\")\n#elif \\\n JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \\\n JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \\\n JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,4,0) || \\\n JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \\\n JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \\\n JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)\n #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma(\"diag_push\")\n #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma(\"diag_pop\")\n#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)\n #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma(\"warning(push)\")\n #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma(\"warning(pop)\")\n#else\n #define JSON_HEDLEY_DIAGNOSTIC_PUSH\n #define JSON_HEDLEY_DIAGNOSTIC_POP\n#endif\n\n/* JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ is for\n HEDLEY INTERNAL USE ONLY. API subject to change without notice. */\n#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)\n #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_\n#endif\n#if defined(__cplusplus)\n# if JSON_HEDLEY_HAS_WARNING(\"-Wc++98-compat\")\n# if JSON_HEDLEY_HAS_WARNING(\"-Wc++17-extensions\")\n# if JSON_HEDLEY_HAS_WARNING(\"-Wc++1z-extensions\")\n# define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \\\n JSON_HEDLEY_DIAGNOSTIC_PUSH \\\n _Pragma(\"clang diagnostic ignored \\\"-Wc++98-compat\\\"\") \\\n _Pragma(\"clang diagnostic ignored \\\"-Wc++17-extensions\\\"\") \\\n _Pragma(\"clang diagnostic ignored \\\"-Wc++1z-extensions\\\"\") \\\n xpr \\\n JSON_HEDLEY_DIAGNOSTIC_POP\n# else\n# define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \\\n JSON_HEDLEY_DIAGNOSTIC_PUSH \\\n _Pragma(\"clang diagnostic ignored \\\"-Wc++98-compat\\\"\") \\\n _Pragma(\"clang diagnostic ignored \\\"-Wc++17-extensions\\\"\") \\\n xpr \\\n JSON_HEDLEY_DIAGNOSTIC_POP\n# endif\n# else\n# define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \\\n JSON_HEDLEY_DIAGNOSTIC_PUSH \\\n _Pragma(\"clang diagnostic ignored \\\"-Wc++98-compat\\\"\") \\\n xpr \\\n JSON_HEDLEY_DIAGNOSTIC_POP\n# endif\n# endif\n#endif\n#if !defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(x) x\n#endif\n\n#if defined(JSON_HEDLEY_CONST_CAST)\n #undef JSON_HEDLEY_CONST_CAST\n#endif\n#if defined(__cplusplus)\n# define JSON_HEDLEY_CONST_CAST(T, expr) (const_cast(expr))\n#elif \\\n JSON_HEDLEY_HAS_WARNING(\"-Wcast-qual\") || \\\n JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) || \\\n JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)\n# define JSON_HEDLEY_CONST_CAST(T, expr) (__extension__ ({ \\\n JSON_HEDLEY_DIAGNOSTIC_PUSH \\\n JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL \\\n ((T) (expr)); \\\n JSON_HEDLEY_DIAGNOSTIC_POP \\\n }))\n#else\n# define JSON_HEDLEY_CONST_CAST(T, expr) ((T) (expr))\n#endif\n\n#if defined(JSON_HEDLEY_REINTERPRET_CAST)\n #undef JSON_HEDLEY_REINTERPRET_CAST\n#endif\n#if defined(__cplusplus)\n #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) (reinterpret_cast(expr))\n#else\n #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) ((T) (expr))\n#endif\n\n#if defined(JSON_HEDLEY_STATIC_CAST)\n #undef JSON_HEDLEY_STATIC_CAST\n#endif\n#if defined(__cplusplus)\n #define JSON_HEDLEY_STATIC_CAST(T, expr) (static_cast(expr))\n#else\n #define JSON_HEDLEY_STATIC_CAST(T, expr) ((T) (expr))\n#endif\n\n#if defined(JSON_HEDLEY_CPP_CAST)\n #undef JSON_HEDLEY_CPP_CAST\n#endif\n#if defined(__cplusplus)\n# if JSON_HEDLEY_HAS_WARNING(\"-Wold-style-cast\")\n# define JSON_HEDLEY_CPP_CAST(T, expr) \\\n JSON_HEDLEY_DIAGNOSTIC_PUSH \\\n _Pragma(\"clang diagnostic ignored \\\"-Wold-style-cast\\\"\") \\\n ((T) (expr)) \\\n JSON_HEDLEY_DIAGNOSTIC_POP\n# elif JSON_HEDLEY_IAR_VERSION_CHECK(8,3,0)\n# define JSON_HEDLEY_CPP_CAST(T, expr) \\\n JSON_HEDLEY_DIAGNOSTIC_PUSH \\\n _Pragma(\"diag_suppress=Pe137\") \\\n JSON_HEDLEY_DIAGNOSTIC_POP\n# else\n# define JSON_HEDLEY_CPP_CAST(T, expr) ((T) (expr))\n# endif\n#else\n# define JSON_HEDLEY_CPP_CAST(T, expr) (expr)\n#endif\n\n#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED)\n #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED\n#endif\n#if JSON_HEDLEY_HAS_WARNING(\"-Wdeprecated-declarations\")\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma(\"clang diagnostic ignored \\\"-Wdeprecated-declarations\\\"\")\n#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma(\"warning(disable:1478 1786)\")\n#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:1478 1786))\n#elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma(\"diag_suppress 1215,1216,1444,1445\")\n#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma(\"diag_suppress 1215,1444\")\n#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma(\"GCC diagnostic ignored \\\"-Wdeprecated-declarations\\\"\")\n#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:4996))\n#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma(\"diag_suppress 1215,1444\")\n#elif \\\n JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \\\n (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \\\n (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \\\n (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \\\n (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \\\n JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \\\n JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma(\"diag_suppress 1291,1718\")\n#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && !defined(__cplusplus)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma(\"error_messages(off,E_DEPRECATED_ATT,E_DEPRECATED_ATT_MESS)\")\n#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && defined(__cplusplus)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma(\"error_messages(off,symdeprecated,symdeprecated2)\")\n#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma(\"diag_suppress=Pe1444,Pe1215\")\n#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma(\"warn(disable:2241)\")\n#else\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED\n#endif\n\n#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS)\n #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS\n#endif\n#if JSON_HEDLEY_HAS_WARNING(\"-Wunknown-pragmas\")\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma(\"clang diagnostic ignored \\\"-Wunknown-pragmas\\\"\")\n#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma(\"warning(disable:161)\")\n#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:161))\n#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma(\"diag_suppress 1675\")\n#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma(\"GCC diagnostic ignored \\\"-Wunknown-pragmas\\\"\")\n#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:4068))\n#elif \\\n JSON_HEDLEY_TI_VERSION_CHECK(16,9,0) || \\\n JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \\\n JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \\\n JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma(\"diag_suppress 163\")\n#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma(\"diag_suppress 163\")\n#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma(\"diag_suppress=Pe161\")\n#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma(\"diag_suppress 161\")\n#else\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS\n#endif\n\n#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES)\n #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES\n#endif\n#if JSON_HEDLEY_HAS_WARNING(\"-Wunknown-attributes\")\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma(\"clang diagnostic ignored \\\"-Wunknown-attributes\\\"\")\n#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma(\"GCC diagnostic ignored \\\"-Wdeprecated-declarations\\\"\")\n#elif JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma(\"warning(disable:1292)\")\n#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:1292))\n#elif JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:5030))\n#elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma(\"diag_suppress 1097,1098\")\n#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma(\"diag_suppress 1097\")\n#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma(\"error_messages(off,attrskipunsup)\")\n#elif \\\n JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \\\n JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \\\n JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma(\"diag_suppress 1173\")\n#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma(\"diag_suppress=Pe1097\")\n#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma(\"diag_suppress 1097\")\n#else\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES\n#endif\n\n#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL)\n #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL\n#endif\n#if JSON_HEDLEY_HAS_WARNING(\"-Wcast-qual\")\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma(\"clang diagnostic ignored \\\"-Wcast-qual\\\"\")\n#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma(\"warning(disable:2203 2331)\")\n#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma(\"GCC diagnostic ignored \\\"-Wcast-qual\\\"\")\n#else\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL\n#endif\n\n#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION)\n #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION\n#endif\n#if JSON_HEDLEY_HAS_WARNING(\"-Wunused-function\")\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma(\"clang diagnostic ignored \\\"-Wunused-function\\\"\")\n#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma(\"GCC diagnostic ignored \\\"-Wunused-function\\\"\")\n#elif JSON_HEDLEY_MSVC_VERSION_CHECK(1,0,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION __pragma(warning(disable:4505))\n#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma(\"diag_suppress 3142\")\n#else\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION\n#endif\n\n#if defined(JSON_HEDLEY_DEPRECATED)\n #undef JSON_HEDLEY_DEPRECATED\n#endif\n#if defined(JSON_HEDLEY_DEPRECATED_FOR)\n #undef JSON_HEDLEY_DEPRECATED_FOR\n#endif\n#if \\\n JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \\\n JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)\n #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated(\"Since \" # since))\n #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated(\"Since \" #since \"; use \" #replacement))\n#elif \\\n (JSON_HEDLEY_HAS_EXTENSION(attribute_deprecated_with_message) && !defined(JSON_HEDLEY_IAR_VERSION)) || \\\n JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \\\n JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \\\n JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \\\n JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) || \\\n JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \\\n JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \\\n JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(18,1,0) || \\\n JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \\\n JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \\\n JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0) || \\\n JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)\n #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__(\"Since \" #since)))\n #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__(\"Since \" #since \"; use \" #replacement)))\n#elif defined(__cplusplus) && (__cplusplus >= 201402L)\n #define JSON_HEDLEY_DEPRECATED(since) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated(\"Since \" #since)]])\n #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated(\"Since \" #since \"; use \" #replacement)]])\n#elif \\\n JSON_HEDLEY_HAS_ATTRIBUTE(deprecated) || \\\n JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \\\n JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \\\n JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \\\n (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \\\n (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \\\n (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \\\n (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \\\n JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \\\n JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \\\n JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \\\n JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)\n #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__))\n #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__))\n#elif \\\n JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \\\n JSON_HEDLEY_PELLES_VERSION_CHECK(6,50,0) || \\\n JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)\n #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated)\n #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated)\n#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)\n #define JSON_HEDLEY_DEPRECATED(since) _Pragma(\"deprecated\")\n #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) _Pragma(\"deprecated\")\n#else\n #define JSON_HEDLEY_DEPRECATED(since)\n #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement)\n#endif\n\n#if defined(JSON_HEDLEY_UNAVAILABLE)\n #undef JSON_HEDLEY_UNAVAILABLE\n#endif\n#if \\\n JSON_HEDLEY_HAS_ATTRIBUTE(warning) || \\\n JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) || \\\n JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \\\n JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)\n #define JSON_HEDLEY_UNAVAILABLE(available_since) __attribute__((__warning__(\"Not available until \" #available_since)))\n#else\n #define JSON_HEDLEY_UNAVAILABLE(available_since)\n#endif\n\n#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT)\n #undef JSON_HEDLEY_WARN_UNUSED_RESULT\n#endif\n#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT_MSG)\n #undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG\n#endif\n#if \\\n JSON_HEDLEY_HAS_ATTRIBUTE(warn_unused_result) || \\\n JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \\\n JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \\\n JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \\\n (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \\\n (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \\\n (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \\\n (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \\\n JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \\\n JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \\\n (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \\\n JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \\\n JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)\n #define JSON_HEDLEY_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__))\n #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) __attribute__((__warn_unused_result__))\n#elif (JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) >= 201907L)\n #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])\n #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard(msg)]])\n#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard)\n #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])\n #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])\n#elif defined(_Check_return_) /* SAL */\n #define JSON_HEDLEY_WARN_UNUSED_RESULT _Check_return_\n #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) _Check_return_\n#else\n #define JSON_HEDLEY_WARN_UNUSED_RESULT\n #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg)\n#endif\n\n#if defined(JSON_HEDLEY_SENTINEL)\n #undef JSON_HEDLEY_SENTINEL\n#endif\n#if \\\n JSON_HEDLEY_HAS_ATTRIBUTE(sentinel) || \\\n JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \\\n JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \\\n JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \\\n JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)\n #define JSON_HEDLEY_SENTINEL(position) __attribute__((__sentinel__(position)))\n#else\n #define JSON_HEDLEY_SENTINEL(position)\n#endif\n\n#if defined(JSON_HEDLEY_NO_RETURN)\n #undef JSON_HEDLEY_NO_RETURN\n#endif\n#if JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)\n #define JSON_HEDLEY_NO_RETURN __noreturn\n#elif \\\n JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \\\n JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)\n #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))\n#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L\n #define JSON_HEDLEY_NO_RETURN _Noreturn\n#elif defined(__cplusplus) && (__cplusplus >= 201103L)\n #define JSON_HEDLEY_NO_RETURN JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[noreturn]])\n#elif \\\n JSON_HEDLEY_HAS_ATTRIBUTE(noreturn) || \\\n JSON_HEDLEY_GCC_VERSION_CHECK(3,2,0) || \\\n JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \\\n JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \\\n JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \\\n JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \\\n (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \\\n (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \\\n (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \\\n (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \\\n JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \\\n JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \\\n JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)\n #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))\n#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)\n #define JSON_HEDLEY_NO_RETURN _Pragma(\"does_not_return\")\n#elif \\\n JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \\\n JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)\n #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)\n#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus)\n #define JSON_HEDLEY_NO_RETURN _Pragma(\"FUNC_NEVER_RETURNS;\")\n#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)\n #define JSON_HEDLEY_NO_RETURN __attribute((noreturn))\n#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)\n #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)\n#else\n #define JSON_HEDLEY_NO_RETURN\n#endif\n\n#if defined(JSON_HEDLEY_NO_ESCAPE)\n #undef JSON_HEDLEY_NO_ESCAPE\n#endif\n#if JSON_HEDLEY_HAS_ATTRIBUTE(noescape)\n #define JSON_HEDLEY_NO_ESCAPE __attribute__((__noescape__))\n#else\n #define JSON_HEDLEY_NO_ESCAPE\n#endif\n\n#if defined(JSON_HEDLEY_UNREACHABLE)\n #undef JSON_HEDLEY_UNREACHABLE\n#endif\n#if defined(JSON_HEDLEY_UNREACHABLE_RETURN)\n #undef JSON_HEDLEY_UNREACHABLE_RETURN\n#endif\n#if defined(JSON_HEDLEY_ASSUME)\n #undef JSON_HEDLEY_ASSUME\n#endif\n#if \\\n JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \\\n JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \\\n JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)\n #define JSON_HEDLEY_ASSUME(expr) __assume(expr)\n#elif JSON_HEDLEY_HAS_BUILTIN(__builtin_assume)\n #define JSON_HEDLEY_ASSUME(expr) __builtin_assume(expr)\n#elif \\\n JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \\\n JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0)\n #if defined(__cplusplus)\n #define JSON_HEDLEY_ASSUME(expr) std::_nassert(expr)\n #else\n #define JSON_HEDLEY_ASSUME(expr) _nassert(expr)\n #endif\n#endif\n#if \\\n (JSON_HEDLEY_HAS_BUILTIN(__builtin_unreachable) && (!defined(JSON_HEDLEY_ARM_VERSION))) || \\\n JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \\\n JSON_HEDLEY_PGI_VERSION_CHECK(18,10,0) || \\\n JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \\\n JSON_HEDLEY_IBM_VERSION_CHECK(13,1,5) || \\\n JSON_HEDLEY_CRAY_VERSION_CHECK(10,0,0) || \\\n JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)\n #define JSON_HEDLEY_UNREACHABLE() __builtin_unreachable()\n#elif defined(JSON_HEDLEY_ASSUME)\n #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)\n#endif\n#if !defined(JSON_HEDLEY_ASSUME)\n #if defined(JSON_HEDLEY_UNREACHABLE)\n #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, ((expr) ? 1 : (JSON_HEDLEY_UNREACHABLE(), 1)))\n #else\n #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, expr)\n #endif\n#endif\n#if defined(JSON_HEDLEY_UNREACHABLE)\n #if \\\n JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \\\n JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0)\n #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (JSON_HEDLEY_STATIC_CAST(void, JSON_HEDLEY_ASSUME(0)), (value))\n #else\n #define JSON_HEDLEY_UNREACHABLE_RETURN(value) JSON_HEDLEY_UNREACHABLE()\n #endif\n#else\n #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (value)\n#endif\n#if !defined(JSON_HEDLEY_UNREACHABLE)\n #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)\n#endif\n\nJSON_HEDLEY_DIAGNOSTIC_PUSH\n#if JSON_HEDLEY_HAS_WARNING(\"-Wpedantic\")\n #pragma clang diagnostic ignored \"-Wpedantic\"\n#endif\n#if JSON_HEDLEY_HAS_WARNING(\"-Wc++98-compat-pedantic\") && defined(__cplusplus)\n #pragma clang diagnostic ignored \"-Wc++98-compat-pedantic\"\n#endif\n#if JSON_HEDLEY_GCC_HAS_WARNING(\"-Wvariadic-macros\",4,0,0)\n #if defined(__clang__)\n #pragma clang diagnostic ignored \"-Wvariadic-macros\"\n #elif defined(JSON_HEDLEY_GCC_VERSION)\n #pragma GCC diagnostic ignored \"-Wvariadic-macros\"\n #endif\n#endif\n#if defined(JSON_HEDLEY_NON_NULL)\n #undef JSON_HEDLEY_NON_NULL\n#endif\n#if \\\n JSON_HEDLEY_HAS_ATTRIBUTE(nonnull) || \\\n JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \\\n JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \\\n JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)\n #define JSON_HEDLEY_NON_NULL(...) __attribute__((__nonnull__(__VA_ARGS__)))\n#else\n #define JSON_HEDLEY_NON_NULL(...)\n#endif\nJSON_HEDLEY_DIAGNOSTIC_POP\n\n#if defined(JSON_HEDLEY_PRINTF_FORMAT)\n #undef JSON_HEDLEY_PRINTF_FORMAT\n#endif\n#if defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && !defined(__USE_MINGW_ANSI_STDIO)\n #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(ms_printf, string_idx, first_to_check)))\n#elif defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && defined(__USE_MINGW_ANSI_STDIO)\n #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(gnu_printf, string_idx, first_to_check)))\n#elif \\\n JSON_HEDLEY_HAS_ATTRIBUTE(format) || \\\n JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \\\n JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \\\n JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \\\n JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \\\n JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \\\n (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \\\n (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \\\n (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \\\n (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \\\n JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \\\n JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \\\n JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)\n #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(__printf__, string_idx, first_to_check)))\n#elif JSON_HEDLEY_PELLES_VERSION_CHECK(6,0,0)\n #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __declspec(vaformat(printf,string_idx,first_to_check))\n#else\n #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check)\n#endif\n\n#if defined(JSON_HEDLEY_CONSTEXPR)\n #undef JSON_HEDLEY_CONSTEXPR\n#endif\n#if defined(__cplusplus)\n #if __cplusplus >= 201103L\n #define JSON_HEDLEY_CONSTEXPR JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(constexpr)\n #endif\n#endif\n#if !defined(JSON_HEDLEY_CONSTEXPR)\n #define JSON_HEDLEY_CONSTEXPR\n#endif\n\n#if defined(JSON_HEDLEY_PREDICT)\n #undef JSON_HEDLEY_PREDICT\n#endif\n#if defined(JSON_HEDLEY_LIKELY)\n #undef JSON_HEDLEY_LIKELY\n#endif\n#if defined(JSON_HEDLEY_UNLIKELY)\n #undef JSON_HEDLEY_UNLIKELY\n#endif\n#if defined(JSON_HEDLEY_UNPREDICTABLE)\n #undef JSON_HEDLEY_UNPREDICTABLE\n#endif\n#if JSON_HEDLEY_HAS_BUILTIN(__builtin_unpredictable)\n #define JSON_HEDLEY_UNPREDICTABLE(expr) __builtin_unpredictable((expr))\n#endif\n#if \\\n (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect_with_probability) && !defined(JSON_HEDLEY_PGI_VERSION)) || \\\n JSON_HEDLEY_GCC_VERSION_CHECK(9,0,0) || \\\n JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)\n# define JSON_HEDLEY_PREDICT(expr, value, probability) __builtin_expect_with_probability( (expr), (value), (probability))\n# define JSON_HEDLEY_PREDICT_TRUE(expr, probability) __builtin_expect_with_probability(!!(expr), 1 , (probability))\n# define JSON_HEDLEY_PREDICT_FALSE(expr, probability) __builtin_expect_with_probability(!!(expr), 0 , (probability))\n# define JSON_HEDLEY_LIKELY(expr) __builtin_expect (!!(expr), 1 )\n# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 )\n#elif \\\n (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \\\n JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \\\n JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \\\n (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \\\n JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \\\n JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \\\n JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \\\n JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \\\n JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \\\n JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \\\n JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \\\n JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \\\n JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \\\n JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,27) || \\\n JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \\\n JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)\n# define JSON_HEDLEY_PREDICT(expr, expected, probability) \\\n (((probability) >= 0.9) ? __builtin_expect((expr), (expected)) : (JSON_HEDLEY_STATIC_CAST(void, expected), (expr)))\n# define JSON_HEDLEY_PREDICT_TRUE(expr, probability) \\\n (__extension__ ({ \\\n double hedley_probability_ = (probability); \\\n ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 1) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 0) : !!(expr))); \\\n }))\n# define JSON_HEDLEY_PREDICT_FALSE(expr, probability) \\\n (__extension__ ({ \\\n double hedley_probability_ = (probability); \\\n ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 0) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 1) : !!(expr))); \\\n }))\n# define JSON_HEDLEY_LIKELY(expr) __builtin_expect(!!(expr), 1)\n# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0)\n#else\n# define JSON_HEDLEY_PREDICT(expr, expected, probability) (JSON_HEDLEY_STATIC_CAST(void, expected), (expr))\n# define JSON_HEDLEY_PREDICT_TRUE(expr, probability) (!!(expr))\n# define JSON_HEDLEY_PREDICT_FALSE(expr, probability) (!!(expr))\n# define JSON_HEDLEY_LIKELY(expr) (!!(expr))\n# define JSON_HEDLEY_UNLIKELY(expr) (!!(expr))\n#endif\n#if !defined(JSON_HEDLEY_UNPREDICTABLE)\n #define JSON_HEDLEY_UNPREDICTABLE(expr) JSON_HEDLEY_PREDICT(expr, 1, 0.5)\n#endif\n\n#if defined(JSON_HEDLEY_MALLOC)\n #undef JSON_HEDLEY_MALLOC\n#endif\n#if \\\n JSON_HEDLEY_HAS_ATTRIBUTE(malloc) || \\\n JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \\\n JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \\\n JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \\\n JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \\\n JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \\\n JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \\\n (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \\\n (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \\\n (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \\\n (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \\\n JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \\\n JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \\\n JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)\n #define JSON_HEDLEY_MALLOC __attribute__((__malloc__))\n#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)\n #define JSON_HEDLEY_MALLOC _Pragma(\"returns_new_memory\")\n#elif \\\n JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \\\n JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)\n #define JSON_HEDLEY_MALLOC __declspec(restrict)\n#else\n #define JSON_HEDLEY_MALLOC\n#endif\n\n#if defined(JSON_HEDLEY_PURE)\n #undef JSON_HEDLEY_PURE\n#endif\n#if \\\n JSON_HEDLEY_HAS_ATTRIBUTE(pure) || \\\n JSON_HEDLEY_GCC_VERSION_CHECK(2,96,0) || \\\n JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \\\n JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \\\n JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \\\n JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \\\n JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \\\n (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \\\n (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \\\n (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \\\n (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \\\n JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \\\n JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \\\n JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \\\n JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)\n# define JSON_HEDLEY_PURE __attribute__((__pure__))\n#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)\n# define JSON_HEDLEY_PURE _Pragma(\"does_not_write_global_data\")\n#elif defined(__cplusplus) && \\\n ( \\\n JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \\\n JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) || \\\n JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) \\\n )\n# define JSON_HEDLEY_PURE _Pragma(\"FUNC_IS_PURE;\")\n#else\n# define JSON_HEDLEY_PURE\n#endif\n\n#if defined(JSON_HEDLEY_CONST)\n #undef JSON_HEDLEY_CONST\n#endif\n#if \\\n JSON_HEDLEY_HAS_ATTRIBUTE(const) || \\\n JSON_HEDLEY_GCC_VERSION_CHECK(2,5,0) || \\\n JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \\\n JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \\\n JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \\\n JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \\\n JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \\\n (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \\\n (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \\\n (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \\\n (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \\\n JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \\\n JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \\\n JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \\\n JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)\n #define JSON_HEDLEY_CONST __attribute__((__const__))\n#elif \\\n JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)\n #define JSON_HEDLEY_CONST _Pragma(\"no_side_effect\")\n#else\n #define JSON_HEDLEY_CONST JSON_HEDLEY_PURE\n#endif\n\n#if defined(JSON_HEDLEY_RESTRICT)\n #undef JSON_HEDLEY_RESTRICT\n#endif\n#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && !defined(__cplusplus)\n #define JSON_HEDLEY_RESTRICT restrict\n#elif \\\n JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \\\n JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \\\n JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \\\n JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \\\n JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \\\n JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \\\n JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \\\n JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \\\n JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,4) || \\\n JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \\\n JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \\\n (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)) || \\\n JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \\\n defined(__clang__) || \\\n JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)\n #define JSON_HEDLEY_RESTRICT __restrict\n#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,3,0) && !defined(__cplusplus)\n #define JSON_HEDLEY_RESTRICT _Restrict\n#else\n #define JSON_HEDLEY_RESTRICT\n#endif\n\n#if defined(JSON_HEDLEY_INLINE)\n #undef JSON_HEDLEY_INLINE\n#endif\n#if \\\n (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \\\n (defined(__cplusplus) && (__cplusplus >= 199711L))\n #define JSON_HEDLEY_INLINE inline\n#elif \\\n defined(JSON_HEDLEY_GCC_VERSION) || \\\n JSON_HEDLEY_ARM_VERSION_CHECK(6,2,0)\n #define JSON_HEDLEY_INLINE __inline__\n#elif \\\n JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \\\n JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \\\n JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \\\n JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,1,0) || \\\n JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \\\n JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \\\n JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \\\n JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \\\n JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \\\n JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)\n #define JSON_HEDLEY_INLINE __inline\n#else\n #define JSON_HEDLEY_INLINE\n#endif\n\n#if defined(JSON_HEDLEY_ALWAYS_INLINE)\n #undef JSON_HEDLEY_ALWAYS_INLINE\n#endif\n#if \\\n JSON_HEDLEY_HAS_ATTRIBUTE(always_inline) || \\\n JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \\\n JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \\\n JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \\\n JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \\\n JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \\\n JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \\\n (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \\\n (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \\\n (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \\\n (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \\\n JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \\\n JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \\\n JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \\\n JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)\n# define JSON_HEDLEY_ALWAYS_INLINE __attribute__((__always_inline__)) JSON_HEDLEY_INLINE\n#elif \\\n JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \\\n JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)\n# define JSON_HEDLEY_ALWAYS_INLINE __forceinline\n#elif defined(__cplusplus) && \\\n ( \\\n JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \\\n JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \\\n JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \\\n JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \\\n JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \\\n JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) \\\n )\n# define JSON_HEDLEY_ALWAYS_INLINE _Pragma(\"FUNC_ALWAYS_INLINE;\")\n#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)\n# define JSON_HEDLEY_ALWAYS_INLINE _Pragma(\"inline=forced\")\n#else\n# define JSON_HEDLEY_ALWAYS_INLINE JSON_HEDLEY_INLINE\n#endif\n\n#if defined(JSON_HEDLEY_NEVER_INLINE)\n #undef JSON_HEDLEY_NEVER_INLINE\n#endif\n#if \\\n JSON_HEDLEY_HAS_ATTRIBUTE(noinline) || \\\n JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \\\n JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \\\n JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \\\n JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \\\n JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \\\n JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \\\n (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \\\n (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \\\n (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \\\n (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \\\n JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \\\n JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \\\n JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \\\n JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)\n #define JSON_HEDLEY_NEVER_INLINE __attribute__((__noinline__))\n#elif \\\n JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \\\n JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)\n #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)\n#elif JSON_HEDLEY_PGI_VERSION_CHECK(10,2,0)\n #define JSON_HEDLEY_NEVER_INLINE _Pragma(\"noinline\")\n#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus)\n #define JSON_HEDLEY_NEVER_INLINE _Pragma(\"FUNC_CANNOT_INLINE;\")\n#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)\n #define JSON_HEDLEY_NEVER_INLINE _Pragma(\"inline=never\")\n#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)\n #define JSON_HEDLEY_NEVER_INLINE __attribute((noinline))\n#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)\n #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)\n#else\n #define JSON_HEDLEY_NEVER_INLINE\n#endif\n\n#if defined(JSON_HEDLEY_PRIVATE)\n #undef JSON_HEDLEY_PRIVATE\n#endif\n#if defined(JSON_HEDLEY_PUBLIC)\n #undef JSON_HEDLEY_PUBLIC\n#endif\n#if defined(JSON_HEDLEY_IMPORT)\n #undef JSON_HEDLEY_IMPORT\n#endif\n#if defined(_WIN32) || defined(__CYGWIN__)\n# define JSON_HEDLEY_PRIVATE\n# define JSON_HEDLEY_PUBLIC __declspec(dllexport)\n# define JSON_HEDLEY_IMPORT __declspec(dllimport)\n#else\n# if \\\n JSON_HEDLEY_HAS_ATTRIBUTE(visibility) || \\\n JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \\\n JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \\\n JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \\\n JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \\\n JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \\\n ( \\\n defined(__TI_EABI__) && \\\n ( \\\n (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) \\\n ) \\\n ) || \\\n JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)\n# define JSON_HEDLEY_PRIVATE __attribute__((__visibility__(\"hidden\")))\n# define JSON_HEDLEY_PUBLIC __attribute__((__visibility__(\"default\")))\n# else\n# define JSON_HEDLEY_PRIVATE\n# define JSON_HEDLEY_PUBLIC\n# endif\n# define JSON_HEDLEY_IMPORT extern\n#endif\n\n#if defined(JSON_HEDLEY_NO_THROW)\n #undef JSON_HEDLEY_NO_THROW\n#endif\n#if \\\n JSON_HEDLEY_HAS_ATTRIBUTE(nothrow) || \\\n JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \\\n JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \\\n JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)\n #define JSON_HEDLEY_NO_THROW __attribute__((__nothrow__))\n#elif \\\n JSON_HEDLEY_MSVC_VERSION_CHECK(13,1,0) || \\\n JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \\\n JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)\n #define JSON_HEDLEY_NO_THROW __declspec(nothrow)\n#else\n #define JSON_HEDLEY_NO_THROW\n#endif\n\n#if defined(JSON_HEDLEY_FALL_THROUGH)\n #undef JSON_HEDLEY_FALL_THROUGH\n#endif\n#if \\\n JSON_HEDLEY_HAS_ATTRIBUTE(fallthrough) || \\\n JSON_HEDLEY_GCC_VERSION_CHECK(7,0,0) || \\\n JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)\n #define JSON_HEDLEY_FALL_THROUGH __attribute__((__fallthrough__))\n#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(clang,fallthrough)\n #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[clang::fallthrough]])\n#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(fallthrough)\n #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[fallthrough]])\n#elif defined(__fallthrough) /* SAL */\n #define JSON_HEDLEY_FALL_THROUGH __fallthrough\n#else\n #define JSON_HEDLEY_FALL_THROUGH\n#endif\n\n#if defined(JSON_HEDLEY_RETURNS_NON_NULL)\n #undef JSON_HEDLEY_RETURNS_NON_NULL\n#endif\n#if \\\n JSON_HEDLEY_HAS_ATTRIBUTE(returns_nonnull) || \\\n JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \\\n JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)\n #define JSON_HEDLEY_RETURNS_NON_NULL __attribute__((__returns_nonnull__))\n#elif defined(_Ret_notnull_) /* SAL */\n #define JSON_HEDLEY_RETURNS_NON_NULL _Ret_notnull_\n#else\n #define JSON_HEDLEY_RETURNS_NON_NULL\n#endif\n\n#if defined(JSON_HEDLEY_ARRAY_PARAM)\n #undef JSON_HEDLEY_ARRAY_PARAM\n#endif\n#if \\\n defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \\\n !defined(__STDC_NO_VLA__) && \\\n !defined(__cplusplus) && \\\n !defined(JSON_HEDLEY_PGI_VERSION) && \\\n !defined(JSON_HEDLEY_TINYC_VERSION)\n #define JSON_HEDLEY_ARRAY_PARAM(name) (name)\n#else\n #define JSON_HEDLEY_ARRAY_PARAM(name)\n#endif\n\n#if defined(JSON_HEDLEY_IS_CONSTANT)\n #undef JSON_HEDLEY_IS_CONSTANT\n#endif\n#if defined(JSON_HEDLEY_REQUIRE_CONSTEXPR)\n #undef JSON_HEDLEY_REQUIRE_CONSTEXPR\n#endif\n/* JSON_HEDLEY_IS_CONSTEXPR_ is for\n HEDLEY INTERNAL USE ONLY. API subject to change without notice. */\n#if defined(JSON_HEDLEY_IS_CONSTEXPR_)\n #undef JSON_HEDLEY_IS_CONSTEXPR_\n#endif\n#if \\\n JSON_HEDLEY_HAS_BUILTIN(__builtin_constant_p) || \\\n JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \\\n JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \\\n JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,19) || \\\n JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \\\n JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \\\n JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \\\n (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) && !defined(__cplusplus)) || \\\n JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \\\n JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)\n #define JSON_HEDLEY_IS_CONSTANT(expr) __builtin_constant_p(expr)\n#endif\n#if !defined(__cplusplus)\n# if \\\n JSON_HEDLEY_HAS_BUILTIN(__builtin_types_compatible_p) || \\\n JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \\\n JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \\\n JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \\\n JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \\\n JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \\\n JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,24)\n#if defined(__INTPTR_TYPE__)\n #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0)), int*)\n#else\n #include \n #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((intptr_t) ((expr) * 0)) : (int*) 0)), int*)\n#endif\n# elif \\\n ( \\\n defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) && \\\n !defined(JSON_HEDLEY_SUNPRO_VERSION) && \\\n !defined(JSON_HEDLEY_PGI_VERSION) && \\\n !defined(JSON_HEDLEY_IAR_VERSION)) || \\\n (JSON_HEDLEY_HAS_EXTENSION(c_generic_selections) && !defined(JSON_HEDLEY_IAR_VERSION)) || \\\n JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \\\n JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0) || \\\n JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \\\n JSON_HEDLEY_ARM_VERSION_CHECK(5,3,0)\n#if defined(__INTPTR_TYPE__)\n #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0), int*: 1, void*: 0)\n#else\n #include \n #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((intptr_t) * 0) : (int*) 0), int*: 1, void*: 0)\n#endif\n# elif \\\n defined(JSON_HEDLEY_GCC_VERSION) || \\\n defined(JSON_HEDLEY_INTEL_VERSION) || \\\n defined(JSON_HEDLEY_TINYC_VERSION) || \\\n defined(JSON_HEDLEY_TI_ARMCL_VERSION) || \\\n JSON_HEDLEY_TI_CL430_VERSION_CHECK(18,12,0) || \\\n defined(JSON_HEDLEY_TI_CL2000_VERSION) || \\\n defined(JSON_HEDLEY_TI_CL6X_VERSION) || \\\n defined(JSON_HEDLEY_TI_CL7X_VERSION) || \\\n defined(JSON_HEDLEY_TI_CLPRU_VERSION) || \\\n defined(__clang__)\n# define JSON_HEDLEY_IS_CONSTEXPR_(expr) ( \\\n sizeof(void) != \\\n sizeof(*( \\\n 1 ? \\\n ((void*) ((expr) * 0L) ) : \\\n((struct { char v[sizeof(void) * 2]; } *) 1) \\\n ) \\\n ) \\\n )\n# endif\n#endif\n#if defined(JSON_HEDLEY_IS_CONSTEXPR_)\n #if !defined(JSON_HEDLEY_IS_CONSTANT)\n #define JSON_HEDLEY_IS_CONSTANT(expr) JSON_HEDLEY_IS_CONSTEXPR_(expr)\n #endif\n #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (JSON_HEDLEY_IS_CONSTEXPR_(expr) ? (expr) : (-1))\n#else\n #if !defined(JSON_HEDLEY_IS_CONSTANT)\n #define JSON_HEDLEY_IS_CONSTANT(expr) (0)\n #endif\n #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (expr)\n#endif\n\n#if defined(JSON_HEDLEY_BEGIN_C_DECLS)\n #undef JSON_HEDLEY_BEGIN_C_DECLS\n#endif\n#if defined(JSON_HEDLEY_END_C_DECLS)\n #undef JSON_HEDLEY_END_C_DECLS\n#endif\n#if defined(JSON_HEDLEY_C_DECL)\n #undef JSON_HEDLEY_C_DECL\n#endif\n#if defined(__cplusplus)\n #define JSON_HEDLEY_BEGIN_C_DECLS extern \"C\" {\n #define JSON_HEDLEY_END_C_DECLS }\n #define JSON_HEDLEY_C_DECL extern \"C\"\n#else\n #define JSON_HEDLEY_BEGIN_C_DECLS\n #define JSON_HEDLEY_END_C_DECLS\n #define JSON_HEDLEY_C_DECL\n#endif\n\n#if defined(JSON_HEDLEY_STATIC_ASSERT)\n #undef JSON_HEDLEY_STATIC_ASSERT\n#endif\n#if \\\n !defined(__cplusplus) && ( \\\n (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)) || \\\n (JSON_HEDLEY_HAS_FEATURE(c_static_assert) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \\\n JSON_HEDLEY_GCC_VERSION_CHECK(6,0,0) || \\\n JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \\\n defined(_Static_assert) \\\n )\n# define JSON_HEDLEY_STATIC_ASSERT(expr, message) _Static_assert(expr, message)\n#elif \\\n (defined(__cplusplus) && (__cplusplus >= 201103L)) || \\\n JSON_HEDLEY_MSVC_VERSION_CHECK(16,0,0) || \\\n JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)\n# define JSON_HEDLEY_STATIC_ASSERT(expr, message) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(static_assert(expr, message))\n#else\n# define JSON_HEDLEY_STATIC_ASSERT(expr, message)\n#endif\n\n#if defined(JSON_HEDLEY_NULL)\n #undef JSON_HEDLEY_NULL\n#endif\n#if defined(__cplusplus)\n #if __cplusplus >= 201103L\n #define JSON_HEDLEY_NULL JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(nullptr)\n #elif defined(NULL)\n #define JSON_HEDLEY_NULL NULL\n #else\n #define JSON_HEDLEY_NULL JSON_HEDLEY_STATIC_CAST(void*, 0)\n #endif\n#elif defined(NULL)\n #define JSON_HEDLEY_NULL NULL\n#else\n #define JSON_HEDLEY_NULL ((void*) 0)\n#endif\n\n#if defined(JSON_HEDLEY_MESSAGE)\n #undef JSON_HEDLEY_MESSAGE\n#endif\n#if JSON_HEDLEY_HAS_WARNING(\"-Wunknown-pragmas\")\n# define JSON_HEDLEY_MESSAGE(msg) \\\n JSON_HEDLEY_DIAGNOSTIC_PUSH \\\n JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \\\n JSON_HEDLEY_PRAGMA(message msg) \\\n JSON_HEDLEY_DIAGNOSTIC_POP\n#elif \\\n JSON_HEDLEY_GCC_VERSION_CHECK(4,4,0) || \\\n JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)\n# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message msg)\n#elif JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0)\n# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(_CRI message msg)\n#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)\n# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))\n#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,0,0)\n# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))\n#else\n# define JSON_HEDLEY_MESSAGE(msg)\n#endif\n\n#if defined(JSON_HEDLEY_WARNING)\n #undef JSON_HEDLEY_WARNING\n#endif\n#if JSON_HEDLEY_HAS_WARNING(\"-Wunknown-pragmas\")\n# define JSON_HEDLEY_WARNING(msg) \\\n JSON_HEDLEY_DIAGNOSTIC_PUSH \\\n JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \\\n JSON_HEDLEY_PRAGMA(clang warning msg) \\\n JSON_HEDLEY_DIAGNOSTIC_POP\n#elif \\\n JSON_HEDLEY_GCC_VERSION_CHECK(4,8,0) || \\\n JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \\\n JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)\n# define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(GCC warning msg)\n#elif \\\n JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \\\n JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)\n# define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(message(msg))\n#else\n# define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_MESSAGE(msg)\n#endif\n\n#if defined(JSON_HEDLEY_REQUIRE)\n #undef JSON_HEDLEY_REQUIRE\n#endif\n#if defined(JSON_HEDLEY_REQUIRE_MSG)\n #undef JSON_HEDLEY_REQUIRE_MSG\n#endif\n#if JSON_HEDLEY_HAS_ATTRIBUTE(diagnose_if)\n# if JSON_HEDLEY_HAS_WARNING(\"-Wgcc-compat\")\n# define JSON_HEDLEY_REQUIRE(expr) \\\n JSON_HEDLEY_DIAGNOSTIC_PUSH \\\n _Pragma(\"clang diagnostic ignored \\\"-Wgcc-compat\\\"\") \\\n __attribute__((diagnose_if(!(expr), #expr, \"error\"))) \\\n JSON_HEDLEY_DIAGNOSTIC_POP\n# define JSON_HEDLEY_REQUIRE_MSG(expr,msg) \\\n JSON_HEDLEY_DIAGNOSTIC_PUSH \\\n _Pragma(\"clang diagnostic ignored \\\"-Wgcc-compat\\\"\") \\\n __attribute__((diagnose_if(!(expr), msg, \"error\"))) \\\n JSON_HEDLEY_DIAGNOSTIC_POP\n# else\n# define JSON_HEDLEY_REQUIRE(expr) __attribute__((diagnose_if(!(expr), #expr, \"error\")))\n# define JSON_HEDLEY_REQUIRE_MSG(expr,msg) __attribute__((diagnose_if(!(expr), msg, \"error\")))\n# endif\n#else\n# define JSON_HEDLEY_REQUIRE(expr)\n# define JSON_HEDLEY_REQUIRE_MSG(expr,msg)\n#endif\n\n#if defined(JSON_HEDLEY_FLAGS)\n #undef JSON_HEDLEY_FLAGS\n#endif\n#if JSON_HEDLEY_HAS_ATTRIBUTE(flag_enum) && (!defined(__cplusplus) || JSON_HEDLEY_HAS_WARNING(\"-Wbitfield-enum-conversion\"))\n #define JSON_HEDLEY_FLAGS __attribute__((__flag_enum__))\n#else\n #define JSON_HEDLEY_FLAGS\n#endif\n\n#if defined(JSON_HEDLEY_FLAGS_CAST)\n #undef JSON_HEDLEY_FLAGS_CAST\n#endif\n#if JSON_HEDLEY_INTEL_VERSION_CHECK(19,0,0)\n# define JSON_HEDLEY_FLAGS_CAST(T, expr) (__extension__ ({ \\\n JSON_HEDLEY_DIAGNOSTIC_PUSH \\\n _Pragma(\"warning(disable:188)\") \\\n ((T) (expr)); \\\n JSON_HEDLEY_DIAGNOSTIC_POP \\\n }))\n#else\n# define JSON_HEDLEY_FLAGS_CAST(T, expr) JSON_HEDLEY_STATIC_CAST(T, expr)\n#endif\n\n#if defined(JSON_HEDLEY_EMPTY_BASES)\n #undef JSON_HEDLEY_EMPTY_BASES\n#endif\n#if \\\n (JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,23918) && !JSON_HEDLEY_MSVC_VERSION_CHECK(20,0,0)) || \\\n JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)\n #define JSON_HEDLEY_EMPTY_BASES __declspec(empty_bases)\n#else\n #define JSON_HEDLEY_EMPTY_BASES\n#endif\n\n/* Remaining macros are deprecated. */\n\n#if defined(JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK)\n #undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK\n#endif\n#if defined(__clang__)\n #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) (0)\n#else\n #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)\n#endif\n\n#if defined(JSON_HEDLEY_CLANG_HAS_ATTRIBUTE)\n #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE\n#endif\n#define JSON_HEDLEY_CLANG_HAS_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)\n\n#if defined(JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE)\n #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE\n#endif\n#define JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute)\n\n#if defined(JSON_HEDLEY_CLANG_HAS_BUILTIN)\n #undef JSON_HEDLEY_CLANG_HAS_BUILTIN\n#endif\n#define JSON_HEDLEY_CLANG_HAS_BUILTIN(builtin) JSON_HEDLEY_HAS_BUILTIN(builtin)\n\n#if defined(JSON_HEDLEY_CLANG_HAS_FEATURE)\n #undef JSON_HEDLEY_CLANG_HAS_FEATURE\n#endif\n#define JSON_HEDLEY_CLANG_HAS_FEATURE(feature) JSON_HEDLEY_HAS_FEATURE(feature)\n\n#if defined(JSON_HEDLEY_CLANG_HAS_EXTENSION)\n #undef JSON_HEDLEY_CLANG_HAS_EXTENSION\n#endif\n#define JSON_HEDLEY_CLANG_HAS_EXTENSION(extension) JSON_HEDLEY_HAS_EXTENSION(extension)\n\n#if defined(JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE)\n #undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE\n#endif\n#define JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute)\n\n#if defined(JSON_HEDLEY_CLANG_HAS_WARNING)\n #undef JSON_HEDLEY_CLANG_HAS_WARNING\n#endif\n#define JSON_HEDLEY_CLANG_HAS_WARNING(warning) JSON_HEDLEY_HAS_WARNING(warning)\n\n#endif /* !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < X) */\n\n\n// This file contains all internal macro definitions (except those affecting ABI)\n// You MUST include macro_unscope.hpp at the end of json.hpp to undef all of them\n\n// #include \n\n\n// exclude unsupported compilers\n#if !defined(JSON_SKIP_UNSUPPORTED_COMPILER_CHECK)\n #if defined(__clang__)\n #if (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) < 30400\n #error \"unsupported Clang version - see https://github.com/nlohmann/json#supported-compilers\"\n #endif\n #elif defined(__GNUC__) && !(defined(__ICC) || defined(__INTEL_COMPILER))\n #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40800\n #error \"unsupported GCC version - see https://github.com/nlohmann/json#supported-compilers\"\n #endif\n #endif\n#endif\n\n// C++ language standard detection\n// if the user manually specified the used c++ version this is skipped\n#if !defined(JSON_HAS_CPP_23) && !defined(JSON_HAS_CPP_20) && !defined(JSON_HAS_CPP_17) && !defined(JSON_HAS_CPP_14) && !defined(JSON_HAS_CPP_11)\n #if (defined(__cplusplus) && __cplusplus > 202002L) || (defined(_MSVC_LANG) && _MSVC_LANG > 202002L)\n #define JSON_HAS_CPP_23\n #define JSON_HAS_CPP_20\n #define JSON_HAS_CPP_17\n #define JSON_HAS_CPP_14\n #elif (defined(__cplusplus) && __cplusplus > 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG > 201703L)\n #define JSON_HAS_CPP_20\n #define JSON_HAS_CPP_17\n #define JSON_HAS_CPP_14\n #elif (defined(__cplusplus) && __cplusplus > 201402L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464\n #define JSON_HAS_CPP_17\n #define JSON_HAS_CPP_14\n #elif (defined(__cplusplus) && __cplusplus > 201103L) || (defined(_HAS_CXX14) && _HAS_CXX14 == 1)\n #define JSON_HAS_CPP_14\n #endif\n // the cpp 11 flag is always specified because it is the minimal required version\n #define JSON_HAS_CPP_11\n#endif\n\n#ifdef __has_include\n #if __has_include()\n #include \n #endif\n#endif\n\n#if !defined(JSON_HAS_FILESYSTEM) && !defined(JSON_HAS_EXPERIMENTAL_FILESYSTEM)\n #ifdef JSON_HAS_CPP_17\n #if defined(__cpp_lib_filesystem)\n #define JSON_HAS_FILESYSTEM 1\n #elif defined(__cpp_lib_experimental_filesystem)\n #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1\n #elif !defined(__has_include)\n #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1\n #elif __has_include()\n #define JSON_HAS_FILESYSTEM 1\n #elif __has_include()\n #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1\n #endif\n\n // std::filesystem does not work on MinGW GCC 8: https://sourceforge.net/p/mingw-w64/bugs/737/\n #if defined(__MINGW32__) && defined(__GNUC__) && __GNUC__ == 8\n #undef JSON_HAS_FILESYSTEM\n #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM\n #endif\n\n // no filesystem support before GCC 8: https://en.cppreference.com/w/cpp/compiler_support\n #if defined(__GNUC__) && !defined(__clang__) && __GNUC__ < 8\n #undef JSON_HAS_FILESYSTEM\n #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM\n #endif\n\n // no filesystem support before Clang 7: https://en.cppreference.com/w/cpp/compiler_support\n #if defined(__clang_major__) && __clang_major__ < 7\n #undef JSON_HAS_FILESYSTEM\n #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM\n #endif\n\n // no filesystem support before MSVC 19.14: https://en.cppreference.com/w/cpp/compiler_support\n #if defined(_MSC_VER) && _MSC_VER < 1914\n #undef JSON_HAS_FILESYSTEM\n #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM\n #endif\n\n // no filesystem support before iOS 13\n #if defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && __IPHONE_OS_VERSION_MIN_REQUIRED < 130000\n #undef JSON_HAS_FILESYSTEM\n #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM\n #endif\n\n // no filesystem support before macOS Catalina\n #if defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && __MAC_OS_X_VERSION_MIN_REQUIRED < 101500\n #undef JSON_HAS_FILESYSTEM\n #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM\n #endif\n #endif\n#endif\n\n#ifndef JSON_HAS_EXPERIMENTAL_FILESYSTEM\n #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 0\n#endif\n\n#ifndef JSON_HAS_FILESYSTEM\n #define JSON_HAS_FILESYSTEM 0\n#endif\n\n#ifndef JSON_HAS_THREE_WAY_COMPARISON\n #if defined(__cpp_impl_three_way_comparison) && __cpp_impl_three_way_comparison >= 201907L \\\n && defined(__cpp_lib_three_way_comparison) && __cpp_lib_three_way_comparison >= 201907L\n #define JSON_HAS_THREE_WAY_COMPARISON 1\n #else\n #define JSON_HAS_THREE_WAY_COMPARISON 0\n #endif\n#endif\n\n#ifndef JSON_HAS_RANGES\n // ranges header shipping in GCC 11.1.0 (released 2021-04-27) has syntax error\n #if defined(__GLIBCXX__) && __GLIBCXX__ == 20210427\n #define JSON_HAS_RANGES 0\n #elif defined(__cpp_lib_ranges)\n #define JSON_HAS_RANGES 1\n #else\n #define JSON_HAS_RANGES 0\n #endif\n#endif\n\n#ifndef JSON_HAS_STATIC_RTTI\n #if !defined(_HAS_STATIC_RTTI) || _HAS_STATIC_RTTI != 0\n #define JSON_HAS_STATIC_RTTI 1\n #else\n #define JSON_HAS_STATIC_RTTI 0\n #endif\n#endif\n\n#ifdef JSON_HAS_CPP_17\n #define JSON_INLINE_VARIABLE inline\n#else\n #define JSON_INLINE_VARIABLE\n#endif\n\n#if JSON_HEDLEY_HAS_ATTRIBUTE(no_unique_address)\n #define JSON_NO_UNIQUE_ADDRESS [[no_unique_address]]\n#else\n #define JSON_NO_UNIQUE_ADDRESS\n#endif\n\n// disable documentation warnings on clang\n#if defined(__clang__)\n #pragma clang diagnostic push\n #pragma clang diagnostic ignored \"-Wdocumentation\"\n #pragma clang diagnostic ignored \"-Wdocumentation-unknown-command\"\n#endif\n\n// allow disabling exceptions\n#if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(JSON_NOEXCEPTION)\n #define JSON_THROW(exception) throw exception\n #define JSON_TRY try\n #define JSON_CATCH(exception) catch(exception)\n #define JSON_INTERNAL_CATCH(exception) catch(exception)\n#else\n #include \n #define JSON_THROW(exception) std::abort()\n #define JSON_TRY if(true)\n #define JSON_CATCH(exception) if(false)\n #define JSON_INTERNAL_CATCH(exception) if(false)\n#endif\n\n// override exception macros\n#if defined(JSON_THROW_USER)\n #undef JSON_THROW\n #define JSON_THROW JSON_THROW_USER\n#endif\n#if defined(JSON_TRY_USER)\n #undef JSON_TRY\n #define JSON_TRY JSON_TRY_USER\n#endif\n#if defined(JSON_CATCH_USER)\n #undef JSON_CATCH\n #define JSON_CATCH JSON_CATCH_USER\n #undef JSON_INTERNAL_CATCH\n #define JSON_INTERNAL_CATCH JSON_CATCH_USER\n#endif\n#if defined(JSON_INTERNAL_CATCH_USER)\n #undef JSON_INTERNAL_CATCH\n #define JSON_INTERNAL_CATCH JSON_INTERNAL_CATCH_USER\n#endif\n\n// allow overriding assert\n#if !defined(JSON_ASSERT)\n #include // assert\n #define JSON_ASSERT(x) assert(x)\n#endif\n\n// allow to access some private functions (needed by the test suite)\n#if defined(JSON_TESTS_PRIVATE)\n #define JSON_PRIVATE_UNLESS_TESTED public\n#else\n #define JSON_PRIVATE_UNLESS_TESTED private\n#endif\n\n/*!\n@brief macro to briefly define a mapping between an enum and JSON\n@def NLOHMANN_JSON_SERIALIZE_ENUM\n@since version 3.4.0\n*/\n#define NLOHMANN_JSON_SERIALIZE_ENUM(ENUM_TYPE, ...) \\\n template \\\n inline void to_json(BasicJsonType& j, const ENUM_TYPE& e) \\\n { \\\n /* NOLINTNEXTLINE(modernize-type-traits) we use C++11 */ \\\n static_assert(std::is_enum::value, #ENUM_TYPE \" must be an enum!\"); \\\n /* NOLINTNEXTLINE(modernize-avoid-c-arrays) we don't want to depend on */ \\\n static const std::pair m[] = __VA_ARGS__; \\\n auto it = std::find_if(std::begin(m), std::end(m), \\\n [e](const std::pair& ej_pair) -> bool \\\n { \\\n return ej_pair.first == e; \\\n }); \\\n j = ((it != std::end(m)) ? it : std::begin(m))->second; \\\n } \\\n template \\\n inline void from_json(const BasicJsonType& j, ENUM_TYPE& e) \\\n { \\\n /* NOLINTNEXTLINE(modernize-type-traits) we use C++11 */ \\\n static_assert(std::is_enum::value, #ENUM_TYPE \" must be an enum!\"); \\\n /* NOLINTNEXTLINE(modernize-avoid-c-arrays) we don't want to depend on */ \\\n static const std::pair m[] = __VA_ARGS__; \\\n auto it = std::find_if(std::begin(m), std::end(m), \\\n [&j](const std::pair& ej_pair) -> bool \\\n { \\\n return ej_pair.second == j; \\\n }); \\\n e = ((it != std::end(m)) ? it : std::begin(m))->first; \\\n }\n\n// Ugly macros to avoid uglier copy-paste when specializing basic_json. They\n// may be removed in the future once the class is split.\n\n#define NLOHMANN_BASIC_JSON_TPL_DECLARATION \\\n template class ObjectType, \\\n template class ArrayType, \\\n class StringType, class BooleanType, class NumberIntegerType, \\\n class NumberUnsignedType, class NumberFloatType, \\\n template class AllocatorType, \\\n template class JSONSerializer, \\\n class BinaryType, \\\n class CustomBaseClass>\n\n#define NLOHMANN_BASIC_JSON_TPL \\\n basic_json\n\n// Macros to simplify conversion from/to types\n\n#define NLOHMANN_JSON_EXPAND( x ) x\n#define NLOHMANN_JSON_GET_MACRO(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, NAME,...) NAME\n#define NLOHMANN_JSON_PASTE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_GET_MACRO(__VA_ARGS__, \\\n NLOHMANN_JSON_PASTE64, \\\n NLOHMANN_JSON_PASTE63, \\\n NLOHMANN_JSON_PASTE62, \\\n NLOHMANN_JSON_PASTE61, \\\n NLOHMANN_JSON_PASTE60, \\\n NLOHMANN_JSON_PASTE59, \\\n NLOHMANN_JSON_PASTE58, \\\n NLOHMANN_JSON_PASTE57, \\\n NLOHMANN_JSON_PASTE56, \\\n NLOHMANN_JSON_PASTE55, \\\n NLOHMANN_JSON_PASTE54, \\\n NLOHMANN_JSON_PASTE53, \\\n NLOHMANN_JSON_PASTE52, \\\n NLOHMANN_JSON_PASTE51, \\\n NLOHMANN_JSON_PASTE50, \\\n NLOHMANN_JSON_PASTE49, \\\n NLOHMANN_JSON_PASTE48, \\\n NLOHMANN_JSON_PASTE47, \\\n NLOHMANN_JSON_PASTE46, \\\n NLOHMANN_JSON_PASTE45, \\\n NLOHMANN_JSON_PASTE44, \\\n NLOHMANN_JSON_PASTE43, \\\n NLOHMANN_JSON_PASTE42, \\\n NLOHMANN_JSON_PASTE41, \\\n NLOHMANN_JSON_PASTE40, \\\n NLOHMANN_JSON_PASTE39, \\\n NLOHMANN_JSON_PASTE38, \\\n NLOHMANN_JSON_PASTE37, \\\n NLOHMANN_JSON_PASTE36, \\\n NLOHMANN_JSON_PASTE35, \\\n NLOHMANN_JSON_PASTE34, \\\n NLOHMANN_JSON_PASTE33, \\\n NLOHMANN_JSON_PASTE32, \\\n NLOHMANN_JSON_PASTE31, \\\n NLOHMANN_JSON_PASTE30, \\\n NLOHMANN_JSON_PASTE29, \\\n NLOHMANN_JSON_PASTE28, \\\n NLOHMANN_JSON_PASTE27, \\\n NLOHMANN_JSON_PASTE26, \\\n NLOHMANN_JSON_PASTE25, \\\n NLOHMANN_JSON_PASTE24, \\\n NLOHMANN_JSON_PASTE23, \\\n NLOHMANN_JSON_PASTE22, \\\n NLOHMANN_JSON_PASTE21, \\\n NLOHMANN_JSON_PASTE20, \\\n NLOHMANN_JSON_PASTE19, \\\n NLOHMANN_JSON_PASTE18, \\\n NLOHMANN_JSON_PASTE17, \\\n NLOHMANN_JSON_PASTE16, \\\n NLOHMANN_JSON_PASTE15, \\\n NLOHMANN_JSON_PASTE14, \\\n NLOHMANN_JSON_PASTE13, \\\n NLOHMANN_JSON_PASTE12, \\\n NLOHMANN_JSON_PASTE11, \\\n NLOHMANN_JSON_PASTE10, \\\n NLOHMANN_JSON_PASTE9, \\\n NLOHMANN_JSON_PASTE8, \\\n NLOHMANN_JSON_PASTE7, \\\n NLOHMANN_JSON_PASTE6, \\\n NLOHMANN_JSON_PASTE5, \\\n NLOHMANN_JSON_PASTE4, \\\n NLOHMANN_JSON_PASTE3, \\\n NLOHMANN_JSON_PASTE2, \\\n NLOHMANN_JSON_PASTE1)(__VA_ARGS__))\n#define NLOHMANN_JSON_PASTE2(func, v1) func(v1)\n#define NLOHMANN_JSON_PASTE3(func, v1, v2) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE2(func, v2)\n#define NLOHMANN_JSON_PASTE4(func, v1, v2, v3) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE3(func, v2, v3)\n#define NLOHMANN_JSON_PASTE5(func, v1, v2, v3, v4) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE4(func, v2, v3, v4)\n#define NLOHMANN_JSON_PASTE6(func, v1, v2, v3, v4, v5) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE5(func, v2, v3, v4, v5)\n#define NLOHMANN_JSON_PASTE7(func, v1, v2, v3, v4, v5, v6) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE6(func, v2, v3, v4, v5, v6)\n#define NLOHMANN_JSON_PASTE8(func, v1, v2, v3, v4, v5, v6, v7) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE7(func, v2, v3, v4, v5, v6, v7)\n#define NLOHMANN_JSON_PASTE9(func, v1, v2, v3, v4, v5, v6, v7, v8) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE8(func, v2, v3, v4, v5, v6, v7, v8)\n#define NLOHMANN_JSON_PASTE10(func, v1, v2, v3, v4, v5, v6, v7, v8, v9) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE9(func, v2, v3, v4, v5, v6, v7, v8, v9)\n#define NLOHMANN_JSON_PASTE11(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE10(func, v2, v3, v4, v5, v6, v7, v8, v9, v10)\n#define NLOHMANN_JSON_PASTE12(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE11(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)\n#define NLOHMANN_JSON_PASTE13(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE12(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12)\n#define NLOHMANN_JSON_PASTE14(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE13(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13)\n#define NLOHMANN_JSON_PASTE15(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE14(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14)\n#define NLOHMANN_JSON_PASTE16(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE15(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15)\n#define NLOHMANN_JSON_PASTE17(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE16(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16)\n#define NLOHMANN_JSON_PASTE18(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE17(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17)\n#define NLOHMANN_JSON_PASTE19(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE18(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18)\n#define NLOHMANN_JSON_PASTE20(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE19(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19)\n#define NLOHMANN_JSON_PASTE21(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE20(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20)\n#define NLOHMANN_JSON_PASTE22(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE21(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21)\n#define NLOHMANN_JSON_PASTE23(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE22(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22)\n#define NLOHMANN_JSON_PASTE24(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE23(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23)\n#define NLOHMANN_JSON_PASTE25(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE24(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24)\n#define NLOHMANN_JSON_PASTE26(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE25(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25)\n#define NLOHMANN_JSON_PASTE27(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE26(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26)\n#define NLOHMANN_JSON_PASTE28(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE27(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27)\n#define NLOHMANN_JSON_PASTE29(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE28(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28)\n#define NLOHMANN_JSON_PASTE30(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE29(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29)\n#define NLOHMANN_JSON_PASTE31(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE30(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30)\n#define NLOHMANN_JSON_PASTE32(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE31(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31)\n#define NLOHMANN_JSON_PASTE33(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE32(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32)\n#define NLOHMANN_JSON_PASTE34(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE33(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33)\n#define NLOHMANN_JSON_PASTE35(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE34(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34)\n#define NLOHMANN_JSON_PASTE36(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE35(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35)\n#define NLOHMANN_JSON_PASTE37(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE36(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36)\n#define NLOHMANN_JSON_PASTE38(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE37(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37)\n#define NLOHMANN_JSON_PASTE39(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE38(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38)\n#define NLOHMANN_JSON_PASTE40(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE39(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39)\n#define NLOHMANN_JSON_PASTE41(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE40(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40)\n#define NLOHMANN_JSON_PASTE42(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE41(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41)\n#define NLOHMANN_JSON_PASTE43(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE42(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42)\n#define NLOHMANN_JSON_PASTE44(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE43(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43)\n#define NLOHMANN_JSON_PASTE45(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE44(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44)\n#define NLOHMANN_JSON_PASTE46(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE45(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45)\n#define NLOHMANN_JSON_PASTE47(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE46(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46)\n#define NLOHMANN_JSON_PASTE48(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE47(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47)\n#define NLOHMANN_JSON_PASTE49(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE48(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48)\n#define NLOHMANN_JSON_PASTE50(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE49(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49)\n#define NLOHMANN_JSON_PASTE51(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE50(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50)\n#define NLOHMANN_JSON_PASTE52(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE51(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51)\n#define NLOHMANN_JSON_PASTE53(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE52(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52)\n#define NLOHMANN_JSON_PASTE54(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE53(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53)\n#define NLOHMANN_JSON_PASTE55(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE54(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54)\n#define NLOHMANN_JSON_PASTE56(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE55(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55)\n#define NLOHMANN_JSON_PASTE57(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE56(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56)\n#define NLOHMANN_JSON_PASTE58(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE57(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57)\n#define NLOHMANN_JSON_PASTE59(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE58(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58)\n#define NLOHMANN_JSON_PASTE60(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE59(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59)\n#define NLOHMANN_JSON_PASTE61(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE60(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60)\n#define NLOHMANN_JSON_PASTE62(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE61(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61)\n#define NLOHMANN_JSON_PASTE63(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE62(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62)\n#define NLOHMANN_JSON_PASTE64(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE63(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63)\n\n#define NLOHMANN_JSON_TO(v1) nlohmann_json_j[#v1] = nlohmann_json_t.v1;\n#define NLOHMANN_JSON_FROM(v1) nlohmann_json_j.at(#v1).get_to(nlohmann_json_t.v1);\n#define NLOHMANN_JSON_FROM_WITH_DEFAULT(v1) nlohmann_json_t.v1 = !nlohmann_json_j.is_null() ? nlohmann_json_j.value(#v1, nlohmann_json_default_obj.v1) : nlohmann_json_default_obj.v1;\n\n/*!\n@brief macro\n@def NLOHMANN_DEFINE_TYPE_INTRUSIVE\n@since version 3.9.0\n@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_intrusive/\n*/\n#define NLOHMANN_DEFINE_TYPE_INTRUSIVE(Type, ...) \\\n template::value, int> = 0> \\\n friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \\\n template::value, int> = 0> \\\n friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }\n\n/*!\n@brief macro\n@def NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT\n@since version 3.11.0\n@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_intrusive/\n*/\n#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(Type, ...) \\\n template::value, int> = 0> \\\n friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \\\n template::value, int> = 0> \\\n friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) }\n\n/*!\n@brief macro\n@def NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE\n@since version 3.11.3\n@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_intrusive/\n*/\n#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE(Type, ...) \\\n template::value, int> = 0> \\\n friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }\n\n/*!\n@brief macro\n@def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE\n@since version 3.9.0\n@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_non_intrusive/\n*/\n#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Type, ...) \\\n template::value, int> = 0> \\\n void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \\\n template::value, int> = 0> \\\n void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }\n\n/*!\n@brief macro\n@def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT\n@since version 3.11.0\n@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_non_intrusive/\n*/\n#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(Type, ...) \\\n template::value, int> = 0> \\\n void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \\\n template::value, int> = 0> \\\n void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) }\n\n/*!\n@brief macro\n@def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE\n@since version 3.11.3\n@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_non_intrusive/\n*/\n#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE(Type, ...) \\\n template::value, int> = 0> \\\n void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }\n\n/*!\n@brief macro\n@def NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE\n@since version 3.12.0\n@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/\n*/\n#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE(Type, BaseType, ...) \\\n template::value, int> = 0> \\\n friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \\\n template::value, int> = 0> \\\n friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }\n\n/*!\n@brief macro\n@def NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT\n@since version 3.12.0\n@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/\n*/\n#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT(Type, BaseType, ...) \\\n template::value, int> = 0> \\\n friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \\\n template::value, int> = 0> \\\n friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast(nlohmann_json_t)); const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) }\n\n/*!\n@brief macro\n@def NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_ONLY_SERIALIZE\n@since version 3.12.0\n@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/\n*/\n#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_ONLY_SERIALIZE(Type, BaseType, ...) \\\n template::value, int> = 0> \\\n friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }\n\n/*!\n@brief macro\n@def NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE\n@since version 3.12.0\n@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/\n*/\n#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE(Type, BaseType, ...) \\\n template::value, int> = 0> \\\n void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \\\n template::value, int> = 0> \\\n void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }\n\n/*!\n@brief macro\n@def NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT\n@since version 3.12.0\n@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/\n*/\n#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT(Type, BaseType, ...) \\\n template::value, int> = 0> \\\n void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \\\n template::value, int> = 0> \\\n void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast(nlohmann_json_t)); const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) }\n\n/*!\n@brief macro\n@def NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE\n@since version 3.12.0\n@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/\n*/\n#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE(Type, BaseType, ...) \\\n template::value, int> = 0> \\\n void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }\n\n// inspired from https://stackoverflow.com/a/26745591\n// allows calling any std function as if (e.g., with begin):\n// using std::begin; begin(x);\n//\n// it allows using the detected idiom to retrieve the return type\n// of such an expression\n#define NLOHMANN_CAN_CALL_STD_FUNC_IMPL(std_name) \\\n namespace detail { \\\n using std::std_name; \\\n \\\n template \\\n using result_of_##std_name = decltype(std_name(std::declval()...)); \\\n } \\\n \\\n namespace detail2 { \\\n struct std_name##_tag \\\n { \\\n }; \\\n \\\n template \\\n std_name##_tag std_name(T&&...); \\\n \\\n template \\\n using result_of_##std_name = decltype(std_name(std::declval()...)); \\\n \\\n template \\\n struct would_call_std_##std_name \\\n { \\\n static constexpr auto const value = ::nlohmann::detail:: \\\n is_detected_exact::value; \\\n }; \\\n } /* namespace detail2 */ \\\n \\\n template \\\n struct would_call_std_##std_name : detail2::would_call_std_##std_name \\\n { \\\n }\n\n#ifndef JSON_USE_IMPLICIT_CONVERSIONS\n #define JSON_USE_IMPLICIT_CONVERSIONS 1\n#endif\n\n#if JSON_USE_IMPLICIT_CONVERSIONS\n #define JSON_EXPLICIT\n#else\n #define JSON_EXPLICIT explicit\n#endif\n\n#ifndef JSON_DISABLE_ENUM_SERIALIZATION\n #define JSON_DISABLE_ENUM_SERIALIZATION 0\n#endif\n\n#ifndef JSON_USE_GLOBAL_UDLS\n #define JSON_USE_GLOBAL_UDLS 1\n#endif\n\n#if JSON_HAS_THREE_WAY_COMPARISON\n #include // partial_ordering\n#endif\n\nNLOHMANN_JSON_NAMESPACE_BEGIN\nnamespace detail\n{\n\n///////////////////////////\n// JSON type enumeration //\n///////////////////////////\n\n/*!\n@brief the JSON type enumeration\n\nThis enumeration collects the different JSON types. It is internally used to\ndistinguish the stored values, and the functions @ref basic_json::is_null(),\n@ref basic_json::is_object(), @ref basic_json::is_array(),\n@ref basic_json::is_string(), @ref basic_json::is_boolean(),\n@ref basic_json::is_number() (with @ref basic_json::is_number_integer(),\n@ref basic_json::is_number_unsigned(), and @ref basic_json::is_number_float()),\n@ref basic_json::is_discarded(), @ref basic_json::is_primitive(), and\n@ref basic_json::is_structured() rely on it.\n\n@note There are three enumeration entries (number_integer, number_unsigned, and\nnumber_float), because the library distinguishes these three types for numbers:\n@ref basic_json::number_unsigned_t is used for unsigned integers,\n@ref basic_json::number_integer_t is used for signed integers, and\n@ref basic_json::number_float_t is used for floating-point numbers or to\napproximate integers which do not fit in the limits of their respective type.\n\n@sa see @ref basic_json::basic_json(const value_t value_type) -- create a JSON\nvalue with the default value for a given type\n\n@since version 1.0.0\n*/\nenum class value_t : std::uint8_t\n{\n null, ///< null value\n object, ///< object (unordered set of name/value pairs)\n array, ///< array (ordered collection of values)\n string, ///< string value\n boolean, ///< boolean value\n number_integer, ///< number value (signed integer)\n number_unsigned, ///< number value (unsigned integer)\n number_float, ///< number value (floating-point)\n binary, ///< binary array (ordered collection of bytes)\n discarded ///< discarded by the parser callback function\n};\n\n/*!\n@brief comparison operator for JSON types\n\nReturns an ordering that is similar to Python:\n- order: null < boolean < number < object < array < string < binary\n- furthermore, each type is not smaller than itself\n- discarded values are not comparable\n- binary is represented as a b\"\" string in python and directly comparable to a\n string; however, making a binary array directly comparable with a string would\n be surprising behavior in a JSON file.\n\n@since version 1.0.0\n*/\n#if JSON_HAS_THREE_WAY_COMPARISON\n inline std::partial_ordering operator<=>(const value_t lhs, const value_t rhs) noexcept // *NOPAD*\n#else\n inline bool operator<(const value_t lhs, const value_t rhs) noexcept\n#endif\n{\n static constexpr std::array order = {{\n 0 /* null */, 3 /* object */, 4 /* array */, 5 /* string */,\n 1 /* boolean */, 2 /* integer */, 2 /* unsigned */, 2 /* float */,\n 6 /* binary */\n }\n };\n\n const auto l_index = static_cast(lhs);\n const auto r_index = static_cast(rhs);\n#if JSON_HAS_THREE_WAY_COMPARISON\n if (l_index < order.size() && r_index < order.size())\n {\n return order[l_index] <=> order[r_index]; // *NOPAD*\n }\n return std::partial_ordering::unordered;\n#else\n return l_index < order.size() && r_index < order.size() && order[l_index] < order[r_index];\n#endif\n}\n\n// GCC selects the built-in operator< over an operator rewritten from\n// a user-defined spaceship operator\n// Clang, MSVC, and ICC select the rewritten candidate\n// (see GCC bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=105200)\n#if JSON_HAS_THREE_WAY_COMPARISON && defined(__GNUC__)\ninline bool operator<(const value_t lhs, const value_t rhs) noexcept\n{\n return std::is_lt(lhs <=> rhs); // *NOPAD*\n}\n#endif\n\n} // namespace detail\nNLOHMANN_JSON_NAMESPACE_END\n\n// #include \n// __ _____ _____ _____\n// __| | __| | | | JSON for Modern C++\n// | | |__ | | | | | | version 3.12.0\n// |_____|_____|_____|_|___| https://github.com/nlohmann/json\n//\n// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann \n// SPDX-License-Identifier: MIT\n\n\n\n// #include \n\n\nNLOHMANN_JSON_NAMESPACE_BEGIN\nnamespace detail\n{\n\n/*!\n@brief replace all occurrences of a substring by another string\n\n@param[in,out] s the string to manipulate; changed so that all\n occurrences of @a f are replaced with @a t\n@param[in] f the substring to replace with @a t\n@param[in] t the string to replace @a f\n\n@pre The search string @a f must not be empty. **This precondition is\nenforced with an assertion.**\n\n@since version 2.0.0\n*/\ntemplate\ninline void replace_substring(StringType& s, const StringType& f,\n const StringType& t)\n{\n JSON_ASSERT(!f.empty());\n for (auto pos = s.find(f); // find first occurrence of f\n pos != StringType::npos; // make sure f was found\n s.replace(pos, f.size(), t), // replace with t, and\n pos = s.find(f, pos + t.size())) // find next occurrence of f\n {}\n}\n\n/*!\n * @brief string escaping as described in RFC 6901 (Sect. 4)\n * @param[in] s string to escape\n * @return escaped string\n *\n * Note the order of escaping \"~\" to \"~0\" and \"/\" to \"~1\" is important.\n */\ntemplate\ninline StringType escape(StringType s)\n{\n replace_substring(s, StringType{\"~\"}, StringType{\"~0\"});\n replace_substring(s, StringType{\"/\"}, StringType{\"~1\"});\n return s;\n}\n\n/*!\n * @brief string unescaping as described in RFC 6901 (Sect. 4)\n * @param[in] s string to unescape\n * @return unescaped string\n *\n * Note the order of escaping \"~1\" to \"/\" and \"~0\" to \"~\" is important.\n */\ntemplate\nstatic void unescape(StringType& s)\n{\n replace_substring(s, StringType{\"~1\"}, StringType{\"/\"});\n replace_substring(s, StringType{\"~0\"}, StringType{\"~\"});\n}\n\n} // namespace detail\nNLOHMANN_JSON_NAMESPACE_END\n\n// #include \n// __ _____ _____ _____\n// __| | __| | | | JSON for Modern C++\n// | | |__ | | | | | | version 3.12.0\n// |_____|_____|_____|_|___| https://github.com/nlohmann/json\n//\n// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann \n// SPDX-License-Identifier: MIT\n\n\n\n#include // size_t\n\n// #include \n\n\nNLOHMANN_JSON_NAMESPACE_BEGIN\nnamespace detail\n{\n\n/// struct to capture the start position of the current token\nstruct position_t\n{\n /// the total number of characters read\n std::size_t chars_read_total = 0;\n /// the number of characters read in the current line\n std::size_t chars_read_current_line = 0;\n /// the number of lines read\n std::size_t lines_read = 0;\n\n /// conversion to size_t to preserve SAX interface\n constexpr operator size_t() const\n {\n return chars_read_total;\n }\n};\n\n} // namespace detail\nNLOHMANN_JSON_NAMESPACE_END\n\n// #include \n\n// #include \n// __ _____ _____ _____\n// __| | __| | | | JSON for Modern C++\n// | | |__ | | | | | | version 3.12.0\n// |_____|_____|_____|_|___| https://github.com/nlohmann/json\n//\n// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann \n// SPDX-FileCopyrightText: 2018 The Abseil Authors\n// SPDX-License-Identifier: MIT\n\n\n\n#include // array\n#include // size_t\n#include // conditional, enable_if, false_type, integral_constant, is_constructible, is_integral, is_same, remove_cv, remove_reference, true_type\n#include // index_sequence, make_index_sequence, index_sequence_for\n\n// #include \n\n\nNLOHMANN_JSON_NAMESPACE_BEGIN\nnamespace detail\n{\n\ntemplate\nusing uncvref_t = typename std::remove_cv::type>::type;\n\n#ifdef JSON_HAS_CPP_14\n\n// the following utilities are natively available in C++14\nusing std::enable_if_t;\nusing std::index_sequence;\nusing std::make_index_sequence;\nusing std::index_sequence_for;\n\n#else\n\n// alias templates to reduce boilerplate\ntemplate\nusing enable_if_t = typename std::enable_if::type;\n\n// The following code is taken from https://github.com/abseil/abseil-cpp/blob/10cb35e459f5ecca5b2ff107635da0bfa41011b4/absl/utility/utility.h\n// which is part of Google Abseil (https://github.com/abseil/abseil-cpp), licensed under the Apache License 2.0.\n\n//// START OF CODE FROM GOOGLE ABSEIL\n\n// integer_sequence\n//\n// Class template representing a compile-time integer sequence. An instantiation\n// of `integer_sequence` has a sequence of integers encoded in its\n// type through its template arguments (which is a common need when\n// working with C++11 variadic templates). `absl::integer_sequence` is designed\n// to be a drop-in replacement for C++14's `std::integer_sequence`.\n//\n// Example:\n//\n// template< class T, T... Ints >\n// void user_function(integer_sequence);\n//\n// int main()\n// {\n// // user_function's `T` will be deduced to `int` and `Ints...`\n// // will be deduced to `0, 1, 2, 3, 4`.\n// user_function(make_integer_sequence());\n// }\ntemplate \nstruct integer_sequence\n{\n using value_type = T;\n static constexpr std::size_t size() noexcept\n {\n return sizeof...(Ints);\n }\n};\n\n// index_sequence\n//\n// A helper template for an `integer_sequence` of `size_t`,\n// `absl::index_sequence` is designed to be a drop-in replacement for C++14's\n// `std::index_sequence`.\ntemplate \nusing index_sequence = integer_sequence;\n\nnamespace utility_internal\n{\n\ntemplate \nstruct Extend;\n\n// Note that SeqSize == sizeof...(Ints). It's passed explicitly for efficiency.\ntemplate \nstruct Extend, SeqSize, 0>\n{\n using type = integer_sequence < T, Ints..., (Ints + SeqSize)... >;\n};\n\ntemplate \nstruct Extend, SeqSize, 1>\n{\n using type = integer_sequence < T, Ints..., (Ints + SeqSize)..., 2 * SeqSize >;\n};\n\n// Recursion helper for 'make_integer_sequence'.\n// 'Gen::type' is an alias for 'integer_sequence'.\ntemplate \nstruct Gen\n{\n using type =\n typename Extend < typename Gen < T, N / 2 >::type, N / 2, N % 2 >::type;\n};\n\ntemplate \nstruct Gen\n{\n using type = integer_sequence;\n};\n\n} // namespace utility_internal\n\n// Compile-time sequences of integers\n\n// make_integer_sequence\n//\n// This template alias is equivalent to\n// `integer_sequence`, and is designed to be a drop-in\n// replacement for C++14's `std::make_integer_sequence`.\ntemplate \nusing make_integer_sequence = typename utility_internal::Gen::type;\n\n// make_index_sequence\n//\n// This template alias is equivalent to `index_sequence<0, 1, ..., N-1>`,\n// and is designed to be a drop-in replacement for C++14's\n// `std::make_index_sequence`.\ntemplate \nusing make_index_sequence = make_integer_sequence;\n\n// index_sequence_for\n//\n// Converts a typename pack into an index sequence of the same length, and\n// is designed to be a drop-in replacement for C++14's\n// `std::index_sequence_for()`\ntemplate \nusing index_sequence_for = make_index_sequence;\n\n//// END OF CODE FROM GOOGLE ABSEIL\n\n#endif\n\n// dispatch utility (taken from ranges-v3)\ntemplate struct priority_tag : priority_tag < N - 1 > {};\ntemplate<> struct priority_tag<0> {};\n\n// taken from ranges-v3\ntemplate\nstruct static_const\n{\n static JSON_INLINE_VARIABLE constexpr T value{};\n};\n\n#ifndef JSON_HAS_CPP_17\n template\n constexpr T static_const::value;\n#endif\n\ntemplate\nconstexpr std::array make_array(Args&& ... args)\n{\n return std::array {{static_cast(std::forward(args))...}};\n}\n\n} // namespace detail\nNLOHMANN_JSON_NAMESPACE_END\n\n// #include \n// __ _____ _____ _____\n// __| | __| | | | JSON for Modern C++\n// | | |__ | | | | | | version 3.12.0\n// |_____|_____|_____|_|___| https://github.com/nlohmann/json\n//\n// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann \n// SPDX-License-Identifier: MIT\n\n\n\n#include // numeric_limits\n#include // char_traits\n#include // tuple\n#include // false_type, is_constructible, is_integral, is_same, true_type\n#include // declval\n\n// #include \n// __ _____ _____ _____\n// __| | __| | | | JSON for Modern C++\n// | | |__ | | | | | | version 3.12.0\n// |_____|_____|_____|_|___| https://github.com/nlohmann/json\n//\n// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann \n// SPDX-License-Identifier: MIT\n\n\n\n#include // random_access_iterator_tag\n\n// #include \n\n// #include \n\n// #include \n\n\nNLOHMANN_JSON_NAMESPACE_BEGIN\nnamespace detail\n{\n\ntemplate\nstruct iterator_types {};\n\ntemplate\nstruct iterator_types <\n It,\n void_t>\n{\n using difference_type = typename It::difference_type;\n using value_type = typename It::value_type;\n using pointer = typename It::pointer;\n using reference = typename It::reference;\n using iterator_category = typename It::iterator_category;\n};\n\n// This is required as some compilers implement std::iterator_traits in a way that\n// doesn't work with SFINAE. See https://github.com/nlohmann/json/issues/1341.\ntemplate\nstruct iterator_traits\n{\n};\n\ntemplate\nstruct iterator_traits < T, enable_if_t < !std::is_pointer::value >>\n : iterator_types\n{\n};\n\ntemplate\nstruct iterator_traits::value>>\n{\n using iterator_category = std::random_access_iterator_tag;\n using value_type = T;\n using difference_type = ptrdiff_t;\n using pointer = T*;\n using reference = T&;\n};\n\n} // namespace detail\nNLOHMANN_JSON_NAMESPACE_END\n\n// #include \n\n// #include \n// __ _____ _____ _____\n// __| | __| | | | JSON for Modern C++\n// | | |__ | | | | | | version 3.12.0\n// |_____|_____|_____|_|___| https://github.com/nlohmann/json\n//\n// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann \n// SPDX-License-Identifier: MIT\n\n\n\n// #include \n\n\nNLOHMANN_JSON_NAMESPACE_BEGIN\n\nNLOHMANN_CAN_CALL_STD_FUNC_IMPL(begin);\n\nNLOHMANN_JSON_NAMESPACE_END\n\n// #include \n// __ _____ _____ _____\n// __| | __| | | | JSON for Modern C++\n// | | |__ | | | | | | version 3.12.0\n// |_____|_____|_____|_|___| https://github.com/nlohmann/json\n//\n// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann \n// SPDX-License-Identifier: MIT\n\n\n\n// #include \n\n\nNLOHMANN_JSON_NAMESPACE_BEGIN\n\nNLOHMANN_CAN_CALL_STD_FUNC_IMPL(end);\n\nNLOHMANN_JSON_NAMESPACE_END\n\n// #include \n\n// #include \n\n// #include \n// __ _____ _____ _____\n// __| | __| | | | JSON for Modern C++\n// | | |__ | | | | | | version 3.12.0\n// |_____|_____|_____|_|___| https://github.com/nlohmann/json\n//\n// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann \n// SPDX-License-Identifier: MIT\n\n#ifndef INCLUDE_NLOHMANN_JSON_FWD_HPP_\n #define INCLUDE_NLOHMANN_JSON_FWD_HPP_\n\n #include // int64_t, uint64_t\n #include // map\n #include // allocator\n #include // string\n #include // vector\n\n // #include \n\n\n /*!\n @brief namespace for Niels Lohmann\n @see https://github.com/nlohmann\n @since version 1.0.0\n */\n NLOHMANN_JSON_NAMESPACE_BEGIN\n\n /*!\n @brief default JSONSerializer template argument\n\n This serializer ignores the template arguments and uses ADL\n ([argument-dependent lookup](https://en.cppreference.com/w/cpp/language/adl))\n for serialization.\n */\n template\n struct adl_serializer;\n\n /// a class to store JSON values\n /// @sa https://json.nlohmann.me/api/basic_json/\n template class ObjectType =\n std::map,\n template class ArrayType = std::vector,\n class StringType = std::string, class BooleanType = bool,\n class NumberIntegerType = std::int64_t,\n class NumberUnsignedType = std::uint64_t,\n class NumberFloatType = double,\n template class AllocatorType = std::allocator,\n template class JSONSerializer =\n adl_serializer,\n class BinaryType = std::vector, // cppcheck-suppress syntaxError\n class CustomBaseClass = void>\n class basic_json;\n\n /// @brief JSON Pointer defines a string syntax for identifying a specific value within a JSON document\n /// @sa https://json.nlohmann.me/api/json_pointer/\n template\n class json_pointer;\n\n /*!\n @brief default specialization\n @sa https://json.nlohmann.me/api/json/\n */\n using json = basic_json<>;\n\n /// @brief a minimal map-like container that preserves insertion order\n /// @sa https://json.nlohmann.me/api/ordered_map/\n template\n struct ordered_map;\n\n /// @brief specialization that maintains the insertion order of object keys\n /// @sa https://json.nlohmann.me/api/ordered_json/\n using ordered_json = basic_json;\n\n NLOHMANN_JSON_NAMESPACE_END\n\n#endif // INCLUDE_NLOHMANN_JSON_FWD_HPP_\n\n\nNLOHMANN_JSON_NAMESPACE_BEGIN\n/*!\n@brief detail namespace with internal helper functions\n\nThis namespace collects functions that should not be exposed,\nimplementations of some @ref basic_json methods, and meta-programming helpers.\n\n@since version 2.1.0\n*/\nnamespace detail\n{\n\n/////////////\n// helpers //\n/////////////\n\n// Note to maintainers:\n//\n// Every trait in this file expects a non CV-qualified type.\n// The only exceptions are in the 'aliases for detected' section\n// (i.e. those of the form: decltype(T::member_function(std::declval())))\n//\n// In this case, T has to be properly CV-qualified to constraint the function arguments\n// (e.g. to_json(BasicJsonType&, const T&))\n\ntemplate struct is_basic_json : std::false_type {};\n\nNLOHMANN_BASIC_JSON_TPL_DECLARATION\nstruct is_basic_json : std::true_type {};\n\n// used by exceptions create() member functions\n// true_type for pointer to possibly cv-qualified basic_json or std::nullptr_t\n// false_type otherwise\ntemplate\nstruct is_basic_json_context :\n std::integral_constant < bool,\n is_basic_json::type>::type>::value\n || std::is_same::value >\n{};\n\n//////////////////////\n// json_ref helpers //\n//////////////////////\n\ntemplate\nclass json_ref;\n\ntemplate\nstruct is_json_ref : std::false_type {};\n\ntemplate\nstruct is_json_ref> : std::true_type {};\n\n//////////////////////////\n// aliases for detected //\n//////////////////////////\n\ntemplate\nusing mapped_type_t = typename T::mapped_type;\n\ntemplate\nusing key_type_t = typename T::key_type;\n\ntemplate\nusing value_type_t = typename T::value_type;\n\ntemplate\nusing difference_type_t = typename T::difference_type;\n\ntemplate\nusing pointer_t = typename T::pointer;\n\ntemplate\nusing reference_t = typename T::reference;\n\ntemplate\nusing iterator_category_t = typename T::iterator_category;\n\ntemplate\nusing to_json_function = decltype(T::to_json(std::declval()...));\n\ntemplate\nusing from_json_function = decltype(T::from_json(std::declval()...));\n\ntemplate\nusing get_template_function = decltype(std::declval().template get());\n\n// trait checking if JSONSerializer::from_json(json const&, udt&) exists\ntemplate\nstruct has_from_json : std::false_type {};\n\n// trait checking if j.get is valid\n// use this trait instead of std::is_constructible or std::is_convertible,\n// both rely on, or make use of implicit conversions, and thus fail when T\n// has several constructors/operator= (see https://github.com/nlohmann/json/issues/958)\ntemplate \nstruct is_getable\n{\n static constexpr bool value = is_detected::value;\n};\n\ntemplate\nstruct has_from_json < BasicJsonType, T, enable_if_t < !is_basic_json::value >>\n{\n using serializer = typename BasicJsonType::template json_serializer;\n\n static constexpr bool value =\n is_detected_exact::value;\n};\n\n// This trait checks if JSONSerializer::from_json(json const&) exists\n// this overload is used for non-default-constructible user-defined-types\ntemplate\nstruct has_non_default_from_json : std::false_type {};\n\ntemplate\nstruct has_non_default_from_json < BasicJsonType, T, enable_if_t < !is_basic_json::value >>\n{\n using serializer = typename BasicJsonType::template json_serializer;\n\n static constexpr bool value =\n is_detected_exact::value;\n};\n\n// This trait checks if BasicJsonType::json_serializer::to_json exists\n// Do not evaluate the trait when T is a basic_json type, to avoid template instantiation infinite recursion.\ntemplate\nstruct has_to_json : std::false_type {};\n\ntemplate\nstruct has_to_json < BasicJsonType, T, enable_if_t < !is_basic_json::value >>\n{\n using serializer = typename BasicJsonType::template json_serializer;\n\n static constexpr bool value =\n is_detected_exact::value;\n};\n\ntemplate\nusing detect_key_compare = typename T::key_compare;\n\ntemplate\nstruct has_key_compare : std::integral_constant::value> {};\n\n// obtains the actual object key comparator\ntemplate\nstruct actual_object_comparator\n{\n using object_t = typename BasicJsonType::object_t;\n using object_comparator_t = typename BasicJsonType::default_object_comparator_t;\n using type = typename std::conditional < has_key_compare::value,\n typename object_t::key_compare, object_comparator_t>::type;\n};\n\ntemplate\nusing actual_object_comparator_t = typename actual_object_comparator::type;\n\n/////////////////\n// char_traits //\n/////////////////\n\n// Primary template of char_traits calls std char_traits\ntemplate\nstruct char_traits : std::char_traits\n{};\n\n// Explicitly define char traits for unsigned char since it is not standard\ntemplate<>\nstruct char_traits : std::char_traits\n{\n using char_type = unsigned char;\n using int_type = uint64_t;\n\n // Redefine to_int_type function\n static int_type to_int_type(char_type c) noexcept\n {\n return static_cast(c);\n }\n\n static char_type to_char_type(int_type i) noexcept\n {\n return static_cast(i);\n }\n\n static constexpr int_type eof() noexcept\n {\n return static_cast(std::char_traits::eof());\n }\n};\n\n// Explicitly define char traits for signed char since it is not standard\ntemplate<>\nstruct char_traits : std::char_traits\n{\n using char_type = signed char;\n using int_type = uint64_t;\n\n // Redefine to_int_type function\n static int_type to_int_type(char_type c) noexcept\n {\n return static_cast(c);\n }\n\n static char_type to_char_type(int_type i) noexcept\n {\n return static_cast(i);\n }\n\n static constexpr int_type eof() noexcept\n {\n return static_cast(std::char_traits::eof());\n }\n};\n\n///////////////////\n// is_ functions //\n///////////////////\n\n// https://en.cppreference.com/w/cpp/types/conjunction\ntemplate struct conjunction : std::true_type { };\ntemplate struct conjunction : B { };\ntemplate\nstruct conjunction\n: std::conditional(B::value), conjunction, B>::type {};\n\n// https://en.cppreference.com/w/cpp/types/negation\ntemplate struct negation : std::integral_constant < bool, !B::value > { };\n\n// Reimplementation of is_constructible and is_default_constructible, due to them being broken for\n// std::pair and std::tuple until LWG 2367 fix (see https://cplusplus.github.io/LWG/lwg-defects.html#2367).\n// This causes compile errors in e.g. clang 3.5 or gcc 4.9.\ntemplate \nstruct is_default_constructible : std::is_default_constructible {};\n\ntemplate \nstruct is_default_constructible>\n : conjunction, is_default_constructible> {};\n\ntemplate \nstruct is_default_constructible>\n : conjunction, is_default_constructible> {};\n\ntemplate \nstruct is_default_constructible>\n : conjunction...> {};\n\ntemplate \nstruct is_default_constructible>\n : conjunction...> {};\n\ntemplate \nstruct is_constructible : std::is_constructible {};\n\ntemplate \nstruct is_constructible> : is_default_constructible> {};\n\ntemplate \nstruct is_constructible> : is_default_constructible> {};\n\ntemplate \nstruct is_constructible> : is_default_constructible> {};\n\ntemplate \nstruct is_constructible> : is_default_constructible> {};\n\ntemplate\nstruct is_iterator_traits : std::false_type {};\n\ntemplate\nstruct is_iterator_traits>\n{\n private:\n using traits = iterator_traits;\n\n public:\n static constexpr auto value =\n is_detected::value &&\n is_detected::value &&\n is_detected::value &&\n is_detected::value &&\n is_detected::value;\n};\n\ntemplate\nstruct is_range\n{\n private:\n using t_ref = typename std::add_lvalue_reference::type;\n\n using iterator = detected_t;\n using sentinel = detected_t;\n\n // to be 100% correct, it should use https://en.cppreference.com/w/cpp/iterator/input_or_output_iterator\n // and https://en.cppreference.com/w/cpp/iterator/sentinel_for\n // but reimplementing these would be too much work, as a lot of other concepts are used underneath\n static constexpr auto is_iterator_begin =\n is_iterator_traits>::value;\n\n public:\n static constexpr bool value = !std::is_same::value && !std::is_same::value && is_iterator_begin;\n};\n\ntemplate\nusing iterator_t = enable_if_t::value, result_of_begin())>>;\n\ntemplate\nusing range_value_t = value_type_t>>;\n\n// The following implementation of is_complete_type is taken from\n// https://blogs.msdn.microsoft.com/vcblog/2015/12/02/partial-support-for-expression-sfinae-in-vs-2015-update-1/\n// and is written by Xiang Fan who agreed to using it in this library.\n\ntemplate\nstruct is_complete_type : std::false_type {};\n\ntemplate\nstruct is_complete_type : std::true_type {};\n\ntemplate\nstruct is_compatible_object_type_impl : std::false_type {};\n\ntemplate\nstruct is_compatible_object_type_impl <\n BasicJsonType, CompatibleObjectType,\n enable_if_t < is_detected::value&&\n is_detected::value >>\n{\n using object_t = typename BasicJsonType::object_t;\n\n // macOS's is_constructible does not play well with nonesuch...\n static constexpr bool value =\n is_constructible::value &&\n is_constructible::value;\n};\n\ntemplate\nstruct is_compatible_object_type\n : is_compatible_object_type_impl {};\n\ntemplate\nstruct is_constructible_object_type_impl : std::false_type {};\n\ntemplate\nstruct is_constructible_object_type_impl <\n BasicJsonType, ConstructibleObjectType,\n enable_if_t < is_detected::value&&\n is_detected::value >>\n{\n using object_t = typename BasicJsonType::object_t;\n\n static constexpr bool value =\n (is_default_constructible::value &&\n (std::is_move_assignable::value ||\n std::is_copy_assignable::value) &&\n (is_constructible::value &&\n std::is_same <\n typename object_t::mapped_type,\n typename ConstructibleObjectType::mapped_type >::value)) ||\n (has_from_json::value ||\n has_non_default_from_json <\n BasicJsonType,\n typename ConstructibleObjectType::mapped_type >::value);\n};\n\ntemplate\nstruct is_constructible_object_type\n : is_constructible_object_type_impl {};\n\ntemplate\nstruct is_compatible_string_type\n{\n static constexpr auto value =\n is_constructible::value;\n};\n\ntemplate\nstruct is_constructible_string_type\n{\n // launder type through decltype() to fix compilation failure on ICPC\n#ifdef __INTEL_COMPILER\n using laundered_type = decltype(std::declval());\n#else\n using laundered_type = ConstructibleStringType;\n#endif\n\n static constexpr auto value =\n conjunction <\n is_constructible,\n is_detected_exact>::value;\n};\n\ntemplate\nstruct is_compatible_array_type_impl : std::false_type {};\n\ntemplate\nstruct is_compatible_array_type_impl <\n BasicJsonType, CompatibleArrayType,\n enable_if_t <\n is_detected::value&&\n is_iterator_traits>>::value&&\n// special case for types like std::filesystem::path whose iterator's value_type are themselves\n// c.f. https://github.com/nlohmann/json/pull/3073\n !std::is_same>::value >>\n{\n static constexpr bool value =\n is_constructible>::value;\n};\n\ntemplate\nstruct is_compatible_array_type\n : is_compatible_array_type_impl {};\n\ntemplate\nstruct is_constructible_array_type_impl : std::false_type {};\n\ntemplate\nstruct is_constructible_array_type_impl <\n BasicJsonType, ConstructibleArrayType,\n enable_if_t::value >>\n : std::true_type {};\n\ntemplate\nstruct is_constructible_array_type_impl <\n BasicJsonType, ConstructibleArrayType,\n enable_if_t < !std::is_same::value&&\n !is_compatible_string_type::value&&\n is_default_constructible::value&&\n(std::is_move_assignable::value ||\n std::is_copy_assignable::value)&&\nis_detected::value&&\nis_iterator_traits>>::value&&\nis_detected::value&&\n// special case for types like std::filesystem::path whose iterator's value_type are themselves\n// c.f. https://github.com/nlohmann/json/pull/3073\n!std::is_same>::value&&\nis_complete_type <\ndetected_t>::value >>\n{\n using value_type = range_value_t;\n\n static constexpr bool value =\n std::is_same::value ||\n has_from_json::value ||\n has_non_default_from_json <\n BasicJsonType,\n value_type >::value;\n};\n\ntemplate\nstruct is_constructible_array_type\n : is_constructible_array_type_impl {};\n\ntemplate\nstruct is_compatible_integer_type_impl : std::false_type {};\n\ntemplate\nstruct is_compatible_integer_type_impl <\n RealIntegerType, CompatibleNumberIntegerType,\n enable_if_t < std::is_integral::value&&\n std::is_integral::value&&\n !std::is_same::value >>\n{\n // is there an assert somewhere on overflows?\n using RealLimits = std::numeric_limits;\n using CompatibleLimits = std::numeric_limits;\n\n static constexpr auto value =\n is_constructible::value &&\n CompatibleLimits::is_integer &&\n RealLimits::is_signed == CompatibleLimits::is_signed;\n};\n\ntemplate\nstruct is_compatible_integer_type\n : is_compatible_integer_type_impl {};\n\ntemplate\nstruct is_compatible_type_impl: std::false_type {};\n\ntemplate\nstruct is_compatible_type_impl <\n BasicJsonType, CompatibleType,\n enable_if_t::value >>\n{\n static constexpr bool value =\n has_to_json::value;\n};\n\ntemplate\nstruct is_compatible_type\n : is_compatible_type_impl {};\n\ntemplate\nstruct is_constructible_tuple : std::false_type {};\n\ntemplate\nstruct is_constructible_tuple> : conjunction...> {};\n\ntemplate\nstruct is_json_iterator_of : std::false_type {};\n\ntemplate\nstruct is_json_iterator_of : std::true_type {};\n\ntemplate\nstruct is_json_iterator_of : std::true_type\n{};\n\n// checks if a given type T is a template specialization of Primary\ntemplate