diff --git a/home/nipa/nipa_out/951794/ynl/old-code/devlink-user.c b/home/nipa/nipa_out/951794/ynl/new-code/devlink-user.c
index 1cbe0c58ebba..1b1a19449133 100644
--- a/home/nipa/nipa_out/951794/ynl/old-code/devlink-user.c
+++ b/home/nipa/nipa_out/951794/ynl/new-code/devlink-user.c
@@ -4952,10 +4952,10 @@ int devlink_region_del(struct ynl_sock *ys, struct devlink_region_del_req *req)
 
 /* ============== DEVLINK_CMD_REGION_READ ============== */
 /* DEVLINK_CMD_REGION_READ - dump */
-int devlink_region_read_rsp_dump_parse(const struct nlmsghdr *nlh,
-				       struct ynl_parse_arg *yarg)
+int devlink_region_read_rsp_parse(const struct nlmsghdr *nlh,
+				  struct ynl_parse_arg *yarg)
 {
-	struct devlink_region_read_rsp_dump *dst;
+	struct devlink_region_read_rsp *dst;
 	const struct nlattr *attr;
 
 	dst = yarg->data;
@@ -5007,8 +5007,7 @@ int devlink_region_read_rsp_dump_parse(const struct nlmsghdr *nlh,
 	return YNL_PARSE_CB_OK;
 }
 
-void
-devlink_region_read_req_dump_free(struct devlink_region_read_req_dump *req)
+void devlink_region_read_req_free(struct devlink_region_read_req *req)
 {
 	free(req->bus_name);
 	free(req->dev_name);
@@ -5016,10 +5015,9 @@ devlink_region_read_req_dump_free(struct devlink_region_read_req_dump *req)
 	free(req);
 }
 
-void
-devlink_region_read_rsp_list_free(struct devlink_region_read_rsp_list *rsp)
+void devlink_region_read_list_free(struct devlink_region_read_list *rsp)
 {
-	struct devlink_region_read_rsp_list *next = rsp;
+	struct devlink_region_read_list *next = rsp;
 
 	while ((void *)next != YNL_LIST_END) {
 		rsp = next;
@@ -5032,9 +5030,9 @@ devlink_region_read_rsp_list_free(struct devlink_region_read_rsp_list *rsp)
 	}
 }
 
-struct devlink_region_read_rsp_list *
+struct devlink_region_read_list *
 devlink_region_read_dump(struct ynl_sock *ys,
-			 struct devlink_region_read_req_dump *req)
+			 struct devlink_region_read_req *req)
 {
 	struct ynl_dump_state yds = {};
 	struct nlmsghdr *nlh;
@@ -5043,8 +5041,8 @@ devlink_region_read_dump(struct ynl_sock *ys,
 	yds.yarg.ys = ys;
 	yds.yarg.rsp_policy = &devlink_nest;
 	yds.yarg.data = NULL;
-	yds.alloc_sz = sizeof(struct devlink_region_read_rsp_list);
-	yds.cb = devlink_region_read_rsp_dump_parse;
+	yds.alloc_sz = sizeof(struct devlink_region_read_list);
+	yds.cb = devlink_region_read_rsp_parse;
 	yds.rsp_cmd = DEVLINK_CMD_REGION_READ;
 
 	nlh = ynl_gemsg_start_dump(ys, ys->family_id, DEVLINK_CMD_REGION_READ, 1);
@@ -5074,7 +5072,7 @@ devlink_region_read_dump(struct ynl_sock *ys,
 	return yds.first;
 
 free_list:
-	devlink_region_read_rsp_list_free(yds.first);
+	devlink_region_read_list_free(yds.first);
 	return NULL;
 }
 
@@ -5794,10 +5792,10 @@ int devlink_health_reporter_diagnose(struct ynl_sock *ys,
 
 /* ============== DEVLINK_CMD_HEALTH_REPORTER_DUMP_GET ============== */
 /* DEVLINK_CMD_HEALTH_REPORTER_DUMP_GET - dump */
-int devlink_health_reporter_dump_get_rsp_dump_parse(const struct nlmsghdr *nlh,
-						    struct ynl_parse_arg *yarg)
+int devlink_health_reporter_dump_get_rsp_parse(const struct nlmsghdr *nlh,
+					       struct ynl_parse_arg *yarg)
 {
-	struct devlink_health_reporter_dump_get_rsp_dump *dst;
+	struct devlink_health_reporter_dump_get_rsp *dst;
 	const struct nlattr *attr;
 	struct ynl_parse_arg parg;
 
@@ -5823,7 +5821,7 @@ int devlink_health_reporter_dump_get_rsp_dump_parse(const struct nlmsghdr *nlh,
 }
 
 void
-devlink_health_reporter_dump_get_req_dump_free(struct devlink_health_reporter_dump_get_req_dump *req)
+devlink_health_reporter_dump_get_req_free(struct devlink_health_reporter_dump_get_req *req)
 {
 	free(req->bus_name);
 	free(req->dev_name);
@@ -5832,9 +5830,9 @@ devlink_health_reporter_dump_get_req_dump_free(struct devlink_health_reporter_du
 }
 
 void
-devlink_health_reporter_dump_get_rsp_list_free(struct devlink_health_reporter_dump_get_rsp_list *rsp)
+devlink_health_reporter_dump_get_list_free(struct devlink_health_reporter_dump_get_list *rsp)
 {
-	struct devlink_health_reporter_dump_get_rsp_list *next = rsp;
+	struct devlink_health_reporter_dump_get_list *next = rsp;
 
 	while ((void *)next != YNL_LIST_END) {
 		rsp = next;
@@ -5845,9 +5843,9 @@ devlink_health_reporter_dump_get_rsp_list_free(struct devlink_health_reporter_du
 	}
 }
 
-struct devlink_health_reporter_dump_get_rsp_list *
+struct devlink_health_reporter_dump_get_list *
 devlink_health_reporter_dump_get_dump(struct ynl_sock *ys,
-				      struct devlink_health_reporter_dump_get_req_dump *req)
+				      struct devlink_health_reporter_dump_get_req *req)
 {
 	struct ynl_dump_state yds = {};
 	struct nlmsghdr *nlh;
@@ -5856,8 +5854,8 @@ devlink_health_reporter_dump_get_dump(struct ynl_sock *ys,
 	yds.yarg.ys = ys;
 	yds.yarg.rsp_policy = &devlink_nest;
 	yds.yarg.data = NULL;
-	yds.alloc_sz = sizeof(struct devlink_health_reporter_dump_get_rsp_list);
-	yds.cb = devlink_health_reporter_dump_get_rsp_dump_parse;
+	yds.alloc_sz = sizeof(struct devlink_health_reporter_dump_get_list);
+	yds.cb = devlink_health_reporter_dump_get_rsp_parse;
 	yds.rsp_cmd = DEVLINK_CMD_HEALTH_REPORTER_DUMP_GET;
 
 	nlh = ynl_gemsg_start_dump(ys, ys->family_id, DEVLINK_CMD_HEALTH_REPORTER_DUMP_GET, 1);
@@ -5879,7 +5877,7 @@ devlink_health_reporter_dump_get_dump(struct ynl_sock *ys,
 	return yds.first;
 
 free_list:
-	devlink_health_reporter_dump_get_rsp_list_free(yds.first);
+	devlink_health_reporter_dump_get_list_free(yds.first);
 	return NULL;
 }
 
diff --git a/home/nipa/nipa_out/951794/ynl/old-code/devlink-user.h b/home/nipa/nipa_out/951794/ynl/new-code/devlink-user.h
index 72175ac3f473..de00d71329c6 100644
--- a/home/nipa/nipa_out/951794/ynl/old-code/devlink-user.h
+++ b/home/nipa/nipa_out/951794/ynl/new-code/devlink-user.h
@@ -3054,7 +3054,7 @@ int devlink_region_del(struct ynl_sock *ys, struct devlink_region_del_req *req);
 
 /* ============== DEVLINK_CMD_REGION_READ ============== */
 /* DEVLINK_CMD_REGION_READ - dump */
-struct devlink_region_read_req_dump {
+struct devlink_region_read_req {
 	struct {
 		__u32 bus_name_len;
 		__u32 dev_name_len;
@@ -3075,17 +3075,16 @@ struct devlink_region_read_req_dump {
 	__u64 region_chunk_len;
 };
 
-static inline struct devlink_region_read_req_dump *
-devlink_region_read_req_dump_alloc(void)
+static inline struct devlink_region_read_req *
+devlink_region_read_req_alloc(void)
 {
-	return calloc(1, sizeof(struct devlink_region_read_req_dump));
+	return calloc(1, sizeof(struct devlink_region_read_req));
 }
-void
-devlink_region_read_req_dump_free(struct devlink_region_read_req_dump *req);
+void devlink_region_read_req_free(struct devlink_region_read_req *req);
 
 static inline void
-devlink_region_read_req_dump_set_bus_name(struct devlink_region_read_req_dump *req,
-					  const char *bus_name)
+devlink_region_read_req_set_bus_name(struct devlink_region_read_req *req,
+				     const char *bus_name)
 {
 	free(req->bus_name);
 	req->_present.bus_name_len = strlen(bus_name);
@@ -3094,8 +3093,8 @@ devlink_region_read_req_dump_set_bus_name(struct devlink_region_read_req_dump *r
 	req->bus_name[req->_present.bus_name_len] = 0;
 }
 static inline void
-devlink_region_read_req_dump_set_dev_name(struct devlink_region_read_req_dump *req,
-					  const char *dev_name)
+devlink_region_read_req_set_dev_name(struct devlink_region_read_req *req,
+				     const char *dev_name)
 {
 	free(req->dev_name);
 	req->_present.dev_name_len = strlen(dev_name);
@@ -3104,15 +3103,15 @@ devlink_region_read_req_dump_set_dev_name(struct devlink_region_read_req_dump *r
 	req->dev_name[req->_present.dev_name_len] = 0;
 }
 static inline void
-devlink_region_read_req_dump_set_port_index(struct devlink_region_read_req_dump *req,
-					    __u32 port_index)
+devlink_region_read_req_set_port_index(struct devlink_region_read_req *req,
+				       __u32 port_index)
 {
 	req->_present.port_index = 1;
 	req->port_index = port_index;
 }
 static inline void
-devlink_region_read_req_dump_set_region_name(struct devlink_region_read_req_dump *req,
-					     const char *region_name)
+devlink_region_read_req_set_region_name(struct devlink_region_read_req *req,
+					const char *region_name)
 {
 	free(req->region_name);
 	req->_present.region_name_len = strlen(region_name);
@@ -3121,33 +3120,33 @@ devlink_region_read_req_dump_set_region_name(struct devlink_region_read_req_dump
 	req->region_name[req->_present.region_name_len] = 0;
 }
 static inline void
-devlink_region_read_req_dump_set_region_snapshot_id(struct devlink_region_read_req_dump *req,
-						    __u32 region_snapshot_id)
+devlink_region_read_req_set_region_snapshot_id(struct devlink_region_read_req *req,
+					       __u32 region_snapshot_id)
 {
 	req->_present.region_snapshot_id = 1;
 	req->region_snapshot_id = region_snapshot_id;
 }
 static inline void
-devlink_region_read_req_dump_set_region_direct(struct devlink_region_read_req_dump *req)
+devlink_region_read_req_set_region_direct(struct devlink_region_read_req *req)
 {
 	req->_present.region_direct = 1;
 }
 static inline void
-devlink_region_read_req_dump_set_region_chunk_addr(struct devlink_region_read_req_dump *req,
-						   __u64 region_chunk_addr)
+devlink_region_read_req_set_region_chunk_addr(struct devlink_region_read_req *req,
+					      __u64 region_chunk_addr)
 {
 	req->_present.region_chunk_addr = 1;
 	req->region_chunk_addr = region_chunk_addr;
 }
 static inline void
-devlink_region_read_req_dump_set_region_chunk_len(struct devlink_region_read_req_dump *req,
-						  __u64 region_chunk_len)
+devlink_region_read_req_set_region_chunk_len(struct devlink_region_read_req *req,
+					     __u64 region_chunk_len)
 {
 	req->_present.region_chunk_len = 1;
 	req->region_chunk_len = region_chunk_len;
 }
 
-struct devlink_region_read_rsp_dump {
+struct devlink_region_read_rsp {
 	struct {
 		__u32 bus_name_len;
 		__u32 dev_name_len;
@@ -3161,17 +3160,16 @@ struct devlink_region_read_rsp_dump {
 	char *region_name;
 };
 
-struct devlink_region_read_rsp_list {
-	struct devlink_region_read_rsp_list *next;
-	struct devlink_region_read_rsp_dump obj __attribute__((aligned(8)));
+struct devlink_region_read_list {
+	struct devlink_region_read_list *next;
+	struct devlink_region_read_rsp obj __attribute__((aligned(8)));
 };
 
-void
-devlink_region_read_rsp_list_free(struct devlink_region_read_rsp_list *rsp);
+void devlink_region_read_list_free(struct devlink_region_read_list *rsp);
 
-struct devlink_region_read_rsp_list *
+struct devlink_region_read_list *
 devlink_region_read_dump(struct ynl_sock *ys,
-			 struct devlink_region_read_req_dump *req);
+			 struct devlink_region_read_req *req);
 
 /* ============== DEVLINK_CMD_PORT_PARAM_GET ============== */
 /* DEVLINK_CMD_PORT_PARAM_GET - do */
@@ -3768,7 +3766,7 @@ int devlink_health_reporter_diagnose(struct ynl_sock *ys,
 
 /* ============== DEVLINK_CMD_HEALTH_REPORTER_DUMP_GET ============== */
 /* DEVLINK_CMD_HEALTH_REPORTER_DUMP_GET - dump */
-struct devlink_health_reporter_dump_get_req_dump {
+struct devlink_health_reporter_dump_get_req {
 	struct {
 		__u32 bus_name_len;
 		__u32 dev_name_len;
@@ -3782,17 +3780,17 @@ struct devlink_health_reporter_dump_get_req_dump {
 	char *health_reporter_name;
 };
 
-static inline struct devlink_health_reporter_dump_get_req_dump *
-devlink_health_reporter_dump_get_req_dump_alloc(void)
+static inline struct devlink_health_reporter_dump_get_req *
+devlink_health_reporter_dump_get_req_alloc(void)
 {
-	return calloc(1, sizeof(struct devlink_health_reporter_dump_get_req_dump));
+	return calloc(1, sizeof(struct devlink_health_reporter_dump_get_req));
 }
 void
-devlink_health_reporter_dump_get_req_dump_free(struct devlink_health_reporter_dump_get_req_dump *req);
+devlink_health_reporter_dump_get_req_free(struct devlink_health_reporter_dump_get_req *req);
 
 static inline void
-devlink_health_reporter_dump_get_req_dump_set_bus_name(struct devlink_health_reporter_dump_get_req_dump *req,
-						       const char *bus_name)
+devlink_health_reporter_dump_get_req_set_bus_name(struct devlink_health_reporter_dump_get_req *req,
+						  const char *bus_name)
 {
 	free(req->bus_name);
 	req->_present.bus_name_len = strlen(bus_name);
@@ -3801,8 +3799,8 @@ devlink_health_reporter_dump_get_req_dump_set_bus_name(struct devlink_health_rep
 	req->bus_name[req->_present.bus_name_len] = 0;
 }
 static inline void
-devlink_health_reporter_dump_get_req_dump_set_dev_name(struct devlink_health_reporter_dump_get_req_dump *req,
-						       const char *dev_name)
+devlink_health_reporter_dump_get_req_set_dev_name(struct devlink_health_reporter_dump_get_req *req,
+						  const char *dev_name)
 {
 	free(req->dev_name);
 	req->_present.dev_name_len = strlen(dev_name);
@@ -3811,15 +3809,15 @@ devlink_health_reporter_dump_get_req_dump_set_dev_name(struct devlink_health_rep
 	req->dev_name[req->_present.dev_name_len] = 0;
 }
 static inline void
-devlink_health_reporter_dump_get_req_dump_set_port_index(struct devlink_health_reporter_dump_get_req_dump *req,
-							 __u32 port_index)
+devlink_health_reporter_dump_get_req_set_port_index(struct devlink_health_reporter_dump_get_req *req,
+						    __u32 port_index)
 {
 	req->_present.port_index = 1;
 	req->port_index = port_index;
 }
 static inline void
-devlink_health_reporter_dump_get_req_dump_set_health_reporter_name(struct devlink_health_reporter_dump_get_req_dump *req,
-								   const char *health_reporter_name)
+devlink_health_reporter_dump_get_req_set_health_reporter_name(struct devlink_health_reporter_dump_get_req *req,
+							      const char *health_reporter_name)
 {
 	free(req->health_reporter_name);
 	req->_present.health_reporter_name_len = strlen(health_reporter_name);
@@ -3828,7 +3826,7 @@ devlink_health_reporter_dump_get_req_dump_set_health_reporter_name(struct devlin
 	req->health_reporter_name[req->_present.health_reporter_name_len] = 0;
 }
 
-struct devlink_health_reporter_dump_get_rsp_dump {
+struct devlink_health_reporter_dump_get_rsp {
 	struct {
 		__u32 fmsg:1;
 	} _present;
@@ -3836,17 +3834,17 @@ struct devlink_health_reporter_dump_get_rsp_dump {
 	struct devlink_dl_fmsg fmsg;
 };
 
-struct devlink_health_reporter_dump_get_rsp_list {
-	struct devlink_health_reporter_dump_get_rsp_list *next;
-	struct devlink_health_reporter_dump_get_rsp_dump obj __attribute__((aligned(8)));
+struct devlink_health_reporter_dump_get_list {
+	struct devlink_health_reporter_dump_get_list *next;
+	struct devlink_health_reporter_dump_get_rsp obj __attribute__((aligned(8)));
 };
 
 void
-devlink_health_reporter_dump_get_rsp_list_free(struct devlink_health_reporter_dump_get_rsp_list *rsp);
+devlink_health_reporter_dump_get_list_free(struct devlink_health_reporter_dump_get_list *rsp);
 
-struct devlink_health_reporter_dump_get_rsp_list *
+struct devlink_health_reporter_dump_get_list *
 devlink_health_reporter_dump_get_dump(struct ynl_sock *ys,
-				      struct devlink_health_reporter_dump_get_req_dump *req);
+				      struct devlink_health_reporter_dump_get_req *req);
 
 /* ============== DEVLINK_CMD_HEALTH_REPORTER_DUMP_CLEAR ============== */
 /* DEVLINK_CMD_HEALTH_REPORTER_DUMP_CLEAR - do */
diff --git a/home/nipa/nipa_out/951794/ynl/old-code/netdev-user.c b/home/nipa/nipa_out/951794/ynl/new-code/netdev-user.c
index d1b9508ea8a0..e39cf5365a04 100644
--- a/home/nipa/nipa_out/951794/ynl/old-code/netdev-user.c
+++ b/home/nipa/nipa_out/951794/ynl/new-code/netdev-user.c
@@ -1126,10 +1126,10 @@ netdev_napi_get_dump(struct ynl_sock *ys, struct netdev_napi_get_req_dump *req)
 
 /* ============== NETDEV_CMD_QSTATS_GET ============== */
 /* NETDEV_CMD_QSTATS_GET - dump */
-int netdev_qstats_get_rsp_dump_parse(const struct nlmsghdr *nlh,
-				     struct ynl_parse_arg *yarg)
+int netdev_qstats_get_rsp_parse(const struct nlmsghdr *nlh,
+				struct ynl_parse_arg *yarg)
 {
-	struct netdev_qstats_get_rsp_dump *dst;
+	struct netdev_qstats_get_rsp *dst;
 	const struct nlattr *attr;
 
 	dst = yarg->data;
@@ -1178,14 +1178,14 @@ int netdev_qstats_get_rsp_dump_parse(const struct nlmsghdr *nlh,
 	return YNL_PARSE_CB_OK;
 }
 
-void netdev_qstats_get_req_dump_free(struct netdev_qstats_get_req_dump *req)
+void netdev_qstats_get_req_free(struct netdev_qstats_get_req *req)
 {
 	free(req);
 }
 
-void netdev_qstats_get_rsp_list_free(struct netdev_qstats_get_rsp_list *rsp)
+void netdev_qstats_get_list_free(struct netdev_qstats_get_list *rsp)
 {
-	struct netdev_qstats_get_rsp_list *next = rsp;
+	struct netdev_qstats_get_list *next = rsp;
 
 	while ((void *)next != YNL_LIST_END) {
 		rsp = next;
@@ -1195,9 +1195,8 @@ void netdev_qstats_get_rsp_list_free(struct netdev_qstats_get_rsp_list *rsp)
 	}
 }
 
-struct netdev_qstats_get_rsp_list *
-netdev_qstats_get_dump(struct ynl_sock *ys,
-		       struct netdev_qstats_get_req_dump *req)
+struct netdev_qstats_get_list *
+netdev_qstats_get_dump(struct ynl_sock *ys, struct netdev_qstats_get_req *req)
 {
 	struct ynl_dump_state yds = {};
 	struct nlmsghdr *nlh;
@@ -1206,8 +1205,8 @@ netdev_qstats_get_dump(struct ynl_sock *ys,
 	yds.yarg.ys = ys;
 	yds.yarg.rsp_policy = &netdev_qstats_nest;
 	yds.yarg.data = NULL;
-	yds.alloc_sz = sizeof(struct netdev_qstats_get_rsp_list);
-	yds.cb = netdev_qstats_get_rsp_dump_parse;
+	yds.alloc_sz = sizeof(struct netdev_qstats_get_list);
+	yds.cb = netdev_qstats_get_rsp_parse;
 	yds.rsp_cmd = NETDEV_CMD_QSTATS_GET;
 
 	nlh = ynl_gemsg_start_dump(ys, ys->family_id, NETDEV_CMD_QSTATS_GET, 1);
@@ -1225,7 +1224,7 @@ netdev_qstats_get_dump(struct ynl_sock *ys,
 	return yds.first;
 
 free_list:
-	netdev_qstats_get_rsp_list_free(yds.first);
+	netdev_qstats_get_list_free(yds.first);
 	return NULL;
 }
 
diff --git a/home/nipa/nipa_out/951794/ynl/old-code/netdev-user.h b/home/nipa/nipa_out/951794/ynl/new-code/netdev-user.h
index bb14a9c81982..8bad23e0c49c 100644
--- a/home/nipa/nipa_out/951794/ynl/old-code/netdev-user.h
+++ b/home/nipa/nipa_out/951794/ynl/new-code/netdev-user.h
@@ -474,7 +474,7 @@ netdev_napi_get_dump(struct ynl_sock *ys, struct netdev_napi_get_req_dump *req);
 
 /* ============== NETDEV_CMD_QSTATS_GET ============== */
 /* NETDEV_CMD_QSTATS_GET - dump */
-struct netdev_qstats_get_req_dump {
+struct netdev_qstats_get_req {
 	struct {
 		__u32 ifindex:1;
 		__u32 scope:1;
@@ -484,29 +484,27 @@ struct netdev_qstats_get_req_dump {
 	__u64 scope;
 };
 
-static inline struct netdev_qstats_get_req_dump *
-netdev_qstats_get_req_dump_alloc(void)
+static inline struct netdev_qstats_get_req *netdev_qstats_get_req_alloc(void)
 {
-	return calloc(1, sizeof(struct netdev_qstats_get_req_dump));
+	return calloc(1, sizeof(struct netdev_qstats_get_req));
 }
-void netdev_qstats_get_req_dump_free(struct netdev_qstats_get_req_dump *req);
+void netdev_qstats_get_req_free(struct netdev_qstats_get_req *req);
 
 static inline void
-netdev_qstats_get_req_dump_set_ifindex(struct netdev_qstats_get_req_dump *req,
-				       __u32 ifindex)
+netdev_qstats_get_req_set_ifindex(struct netdev_qstats_get_req *req,
+				  __u32 ifindex)
 {
 	req->_present.ifindex = 1;
 	req->ifindex = ifindex;
 }
 static inline void
-netdev_qstats_get_req_dump_set_scope(struct netdev_qstats_get_req_dump *req,
-				     __u64 scope)
+netdev_qstats_get_req_set_scope(struct netdev_qstats_get_req *req, __u64 scope)
 {
 	req->_present.scope = 1;
 	req->scope = scope;
 }
 
-struct netdev_qstats_get_rsp_dump {
+struct netdev_qstats_get_rsp {
 	struct {
 		__u32 ifindex:1;
 		__u32 queue_type:1;
@@ -526,16 +524,15 @@ struct netdev_qstats_get_rsp_dump {
 	__u64 tx_bytes;
 };
 
-struct netdev_qstats_get_rsp_list {
-	struct netdev_qstats_get_rsp_list *next;
-	struct netdev_qstats_get_rsp_dump obj __attribute__((aligned(8)));
+struct netdev_qstats_get_list {
+	struct netdev_qstats_get_list *next;
+	struct netdev_qstats_get_rsp obj __attribute__((aligned(8)));
 };
 
-void netdev_qstats_get_rsp_list_free(struct netdev_qstats_get_rsp_list *rsp);
+void netdev_qstats_get_list_free(struct netdev_qstats_get_list *rsp);
 
-struct netdev_qstats_get_rsp_list *
-netdev_qstats_get_dump(struct ynl_sock *ys,
-		       struct netdev_qstats_get_req_dump *req);
+struct netdev_qstats_get_list *
+netdev_qstats_get_dump(struct ynl_sock *ys, struct netdev_qstats_get_req *req);
 
 /* ============== NETDEV_CMD_BIND_RX ============== */
 /* NETDEV_CMD_BIND_RX - do */
diff --git a/home/nipa/nipa_out/951794/ynl/old-code/nfsd-user.c b/home/nipa/nipa_out/951794/ynl/new-code/nfsd-user.c
index e82b2e1287a6..88823d9d921e 100644
--- a/home/nipa/nipa_out/951794/ynl/old-code/nfsd-user.c
+++ b/home/nipa/nipa_out/951794/ynl/new-code/nfsd-user.c
@@ -223,10 +223,10 @@ int nfsd_sock_parse(struct ynl_parse_arg *yarg, const struct nlattr *nested)
 
 /* ============== NFSD_CMD_RPC_STATUS_GET ============== */
 /* NFSD_CMD_RPC_STATUS_GET - dump */
-int nfsd_rpc_status_get_rsp_dump_parse(const struct nlmsghdr *nlh,
-				       struct ynl_parse_arg *yarg)
+int nfsd_rpc_status_get_rsp_parse(const struct nlmsghdr *nlh,
+				  struct ynl_parse_arg *yarg)
 {
-	struct nfsd_rpc_status_get_rsp_dump *dst;
+	struct nfsd_rpc_status_get_rsp *dst;
 	unsigned int n_compound_ops = 0;
 	const struct nlattr *attr;
 	int i;
@@ -329,10 +329,9 @@ int nfsd_rpc_status_get_rsp_dump_parse(const struct nlmsghdr *nlh,
 	return YNL_PARSE_CB_OK;
 }
 
-void
-nfsd_rpc_status_get_rsp_list_free(struct nfsd_rpc_status_get_rsp_list *rsp)
+void nfsd_rpc_status_get_list_free(struct nfsd_rpc_status_get_list *rsp)
 {
-	struct nfsd_rpc_status_get_rsp_list *next = rsp;
+	struct nfsd_rpc_status_get_list *next = rsp;
 
 	while ((void *)next != YNL_LIST_END) {
 		rsp = next;
@@ -345,8 +344,7 @@ nfsd_rpc_status_get_rsp_list_free(struct nfsd_rpc_status_get_rsp_list *rsp)
 	}
 }
 
-struct nfsd_rpc_status_get_rsp_list *
-nfsd_rpc_status_get_dump(struct ynl_sock *ys)
+struct nfsd_rpc_status_get_list *nfsd_rpc_status_get_dump(struct ynl_sock *ys)
 {
 	struct ynl_dump_state yds = {};
 	struct nlmsghdr *nlh;
@@ -355,8 +353,8 @@ nfsd_rpc_status_get_dump(struct ynl_sock *ys)
 	yds.yarg.ys = ys;
 	yds.yarg.rsp_policy = &nfsd_rpc_status_nest;
 	yds.yarg.data = NULL;
-	yds.alloc_sz = sizeof(struct nfsd_rpc_status_get_rsp_list);
-	yds.cb = nfsd_rpc_status_get_rsp_dump_parse;
+	yds.alloc_sz = sizeof(struct nfsd_rpc_status_get_list);
+	yds.cb = nfsd_rpc_status_get_rsp_parse;
 	yds.rsp_cmd = NFSD_CMD_RPC_STATUS_GET;
 
 	nlh = ynl_gemsg_start_dump(ys, ys->family_id, NFSD_CMD_RPC_STATUS_GET, 1);
@@ -368,7 +366,7 @@ nfsd_rpc_status_get_dump(struct ynl_sock *ys)
 	return yds.first;
 
 free_list:
-	nfsd_rpc_status_get_rsp_list_free(yds.first);
+	nfsd_rpc_status_get_list_free(yds.first);
 	return NULL;
 }
 
diff --git a/home/nipa/nipa_out/951794/ynl/old-code/nfsd-user.h b/home/nipa/nipa_out/951794/ynl/new-code/nfsd-user.h
index df568b15267d..6f5db304149f 100644
--- a/home/nipa/nipa_out/951794/ynl/old-code/nfsd-user.h
+++ b/home/nipa/nipa_out/951794/ynl/new-code/nfsd-user.h
@@ -42,7 +42,7 @@ struct nfsd_sock {
 
 /* ============== NFSD_CMD_RPC_STATUS_GET ============== */
 /* NFSD_CMD_RPC_STATUS_GET - dump */
-struct nfsd_rpc_status_get_rsp_dump {
+struct nfsd_rpc_status_get_rsp {
 	struct {
 		__u32 xid:1;
 		__u32 flags:1;
@@ -74,16 +74,14 @@ struct nfsd_rpc_status_get_rsp_dump {
 	__u32 *compound_ops;
 };
 
-struct nfsd_rpc_status_get_rsp_list {
-	struct nfsd_rpc_status_get_rsp_list *next;
-	struct nfsd_rpc_status_get_rsp_dump obj __attribute__((aligned(8)));
+struct nfsd_rpc_status_get_list {
+	struct nfsd_rpc_status_get_list *next;
+	struct nfsd_rpc_status_get_rsp obj __attribute__((aligned(8)));
 };
 
-void
-nfsd_rpc_status_get_rsp_list_free(struct nfsd_rpc_status_get_rsp_list *rsp);
+void nfsd_rpc_status_get_list_free(struct nfsd_rpc_status_get_list *rsp);
 
-struct nfsd_rpc_status_get_rsp_list *
-nfsd_rpc_status_get_dump(struct ynl_sock *ys);
+struct nfsd_rpc_status_get_list *nfsd_rpc_status_get_dump(struct ynl_sock *ys);
 
 /* ============== NFSD_CMD_THREADS_SET ============== */
 /* NFSD_CMD_THREADS_SET - do */
diff --git a/home/nipa/nipa_out/951794/ynl/old-code/nlctrl-user.c b/home/nipa/nipa_out/951794/ynl/new-code/nlctrl-user.c
index 18fe2f6edf23..2d0058cbf635 100644
--- a/home/nipa/nipa_out/951794/ynl/old-code/nlctrl-user.c
+++ b/home/nipa/nipa_out/951794/ynl/new-code/nlctrl-user.c
@@ -504,10 +504,10 @@ struct nlctrl_getfamily_list *nlctrl_getfamily_dump(struct ynl_sock *ys)
 
 /* ============== CTRL_CMD_GETPOLICY ============== */
 /* CTRL_CMD_GETPOLICY - dump */
-int nlctrl_getpolicy_rsp_dump_parse(const struct nlmsghdr *nlh,
-				    struct ynl_parse_arg *yarg)
+int nlctrl_getpolicy_rsp_parse(const struct nlmsghdr *nlh,
+			       struct ynl_parse_arg *yarg)
 {
-	struct nlctrl_getpolicy_rsp_dump *dst;
+	struct nlctrl_getpolicy_rsp *dst;
 	const struct nlattr *attr;
 	struct ynl_parse_arg parg;
 
@@ -556,15 +556,15 @@ int nlctrl_getpolicy_rsp_dump_parse(const struct nlmsghdr *nlh,
 	return YNL_PARSE_CB_OK;
 }
 
-void nlctrl_getpolicy_req_dump_free(struct nlctrl_getpolicy_req_dump *req)
+void nlctrl_getpolicy_req_free(struct nlctrl_getpolicy_req *req)
 {
 	free(req->family_name);
 	free(req);
 }
 
-void nlctrl_getpolicy_rsp_list_free(struct nlctrl_getpolicy_rsp_list *rsp)
+void nlctrl_getpolicy_list_free(struct nlctrl_getpolicy_list *rsp)
 {
-	struct nlctrl_getpolicy_rsp_list *next = rsp;
+	struct nlctrl_getpolicy_list *next = rsp;
 
 	while ((void *)next != YNL_LIST_END) {
 		rsp = next;
@@ -574,9 +574,8 @@ void nlctrl_getpolicy_rsp_list_free(struct nlctrl_getpolicy_rsp_list *rsp)
 	}
 }
 
-struct nlctrl_getpolicy_rsp_list *
-nlctrl_getpolicy_dump(struct ynl_sock *ys,
-		      struct nlctrl_getpolicy_req_dump *req)
+struct nlctrl_getpolicy_list *
+nlctrl_getpolicy_dump(struct ynl_sock *ys, struct nlctrl_getpolicy_req *req)
 {
 	struct ynl_dump_state yds = {};
 	struct nlmsghdr *nlh;
@@ -585,8 +584,8 @@ nlctrl_getpolicy_dump(struct ynl_sock *ys,
 	yds.yarg.ys = ys;
 	yds.yarg.rsp_policy = &nlctrl_ctrl_attrs_nest;
 	yds.yarg.data = NULL;
-	yds.alloc_sz = sizeof(struct nlctrl_getpolicy_rsp_list);
-	yds.cb = nlctrl_getpolicy_rsp_dump_parse;
+	yds.alloc_sz = sizeof(struct nlctrl_getpolicy_list);
+	yds.cb = nlctrl_getpolicy_rsp_parse;
 	yds.rsp_cmd = CTRL_CMD_GETPOLICY;
 
 	nlh = ynl_gemsg_start_dump(ys, ys->family_id, CTRL_CMD_GETPOLICY, 1);
@@ -606,7 +605,7 @@ nlctrl_getpolicy_dump(struct ynl_sock *ys,
 	return yds.first;
 
 free_list:
-	nlctrl_getpolicy_rsp_list_free(yds.first);
+	nlctrl_getpolicy_list_free(yds.first);
 	return NULL;
 }
 
diff --git a/home/nipa/nipa_out/951794/ynl/old-code/nlctrl-user.h b/home/nipa/nipa_out/951794/ynl/new-code/nlctrl-user.h
index e2f727530755..14dacf2d2bf0 100644
--- a/home/nipa/nipa_out/951794/ynl/old-code/nlctrl-user.h
+++ b/home/nipa/nipa_out/951794/ynl/new-code/nlctrl-user.h
@@ -151,7 +151,7 @@ struct nlctrl_getfamily_list *nlctrl_getfamily_dump(struct ynl_sock *ys);
 
 /* ============== CTRL_CMD_GETPOLICY ============== */
 /* CTRL_CMD_GETPOLICY - dump */
-struct nlctrl_getpolicy_req_dump {
+struct nlctrl_getpolicy_req {
 	struct {
 		__u32 family_name_len;
 		__u32 family_id:1;
@@ -163,16 +163,15 @@ struct nlctrl_getpolicy_req_dump {
 	__u32 op;
 };
 
-static inline struct nlctrl_getpolicy_req_dump *
-nlctrl_getpolicy_req_dump_alloc(void)
+static inline struct nlctrl_getpolicy_req *nlctrl_getpolicy_req_alloc(void)
 {
-	return calloc(1, sizeof(struct nlctrl_getpolicy_req_dump));
+	return calloc(1, sizeof(struct nlctrl_getpolicy_req));
 }
-void nlctrl_getpolicy_req_dump_free(struct nlctrl_getpolicy_req_dump *req);
+void nlctrl_getpolicy_req_free(struct nlctrl_getpolicy_req *req);
 
 static inline void
-nlctrl_getpolicy_req_dump_set_family_name(struct nlctrl_getpolicy_req_dump *req,
-					  const char *family_name)
+nlctrl_getpolicy_req_set_family_name(struct nlctrl_getpolicy_req *req,
+				     const char *family_name)
 {
 	free(req->family_name);
 	req->_present.family_name_len = strlen(family_name);
@@ -181,21 +180,20 @@ nlctrl_getpolicy_req_dump_set_family_name(struct nlctrl_getpolicy_req_dump *req,
 	req->family_name[req->_present.family_name_len] = 0;
 }
 static inline void
-nlctrl_getpolicy_req_dump_set_family_id(struct nlctrl_getpolicy_req_dump *req,
-					__u16 family_id)
+nlctrl_getpolicy_req_set_family_id(struct nlctrl_getpolicy_req *req,
+				   __u16 family_id)
 {
 	req->_present.family_id = 1;
 	req->family_id = family_id;
 }
 static inline void
-nlctrl_getpolicy_req_dump_set_op(struct nlctrl_getpolicy_req_dump *req,
-				 __u32 op)
+nlctrl_getpolicy_req_set_op(struct nlctrl_getpolicy_req *req, __u32 op)
 {
 	req->_present.op = 1;
 	req->op = op;
 }
 
-struct nlctrl_getpolicy_rsp_dump {
+struct nlctrl_getpolicy_rsp {
 	struct {
 		__u32 family_id:1;
 		__u32 op_policy:1;
@@ -207,15 +205,14 @@ struct nlctrl_getpolicy_rsp_dump {
 	struct nlctrl_policy_attrs policy;
 };
 
-struct nlctrl_getpolicy_rsp_list {
-	struct nlctrl_getpolicy_rsp_list *next;
-	struct nlctrl_getpolicy_rsp_dump obj __attribute__((aligned(8)));
+struct nlctrl_getpolicy_list {
+	struct nlctrl_getpolicy_list *next;
+	struct nlctrl_getpolicy_rsp obj __attribute__((aligned(8)));
 };
 
-void nlctrl_getpolicy_rsp_list_free(struct nlctrl_getpolicy_rsp_list *rsp);
+void nlctrl_getpolicy_list_free(struct nlctrl_getpolicy_list *rsp);
 
-struct nlctrl_getpolicy_rsp_list *
-nlctrl_getpolicy_dump(struct ynl_sock *ys,
-		      struct nlctrl_getpolicy_req_dump *req);
+struct nlctrl_getpolicy_list *
+nlctrl_getpolicy_dump(struct ynl_sock *ys, struct nlctrl_getpolicy_req *req);
 
 #endif /* _LINUX_NLCTRL_GEN_H */
diff --git a/home/nipa/nipa_out/951794/ynl/new-code/rt-addr-user.c b/home/nipa/nipa_out/951794/ynl/new-code/rt-addr-user.c
new file mode 100644
index 000000000000..817a2deb4ec5
--- /dev/null
+++ b/home/nipa/nipa_out/951794/ynl/new-code/rt-addr-user.c
@@ -0,0 +1,418 @@
+// SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause)
+/* Do not edit directly, auto-generated from: */
+/*	Documentation/netlink/specs/rt-addr.yaml */
+/* YNL-GEN user source */
+
+#include <stdlib.h>
+#include <string.h>
+#include "rt-addr-user.h"
+#include "ynl.h"
+#include <linux/rtnetlink.h>
+
+#include <linux/genetlink.h>
+
+/* Enums */
+static const char * const rt_addr_op_strmap[] = {
+	[20] = "getaddr",
+	[RTM_GETMULTICAST] = "getmulticast",
+};
+
+const char *rt_addr_op_str(int op)
+{
+	if (op < 0 || op >= (int)YNL_ARRAY_SIZE(rt_addr_op_strmap))
+		return NULL;
+	return rt_addr_op_strmap[op];
+}
+
+static const char * const rt_addr_ifa_flags_strmap[] = {
+	[0] = "secondary",
+	[1] = "nodad",
+	[2] = "optimistic",
+	[3] = "dadfailed",
+	[4] = "homeaddress",
+	[5] = "deprecated",
+	[6] = "tentative",
+	[7] = "permanent",
+	[8] = "managetempaddr",
+	[9] = "noprefixroute",
+	[10] = "mcautojoin",
+	[11] = "stable-privacy",
+};
+
+const char *rt_addr_ifa_flags_str(int value)
+{
+	value = ffs(value) - 1;
+	if (value < 0 || value >= (int)YNL_ARRAY_SIZE(rt_addr_ifa_flags_strmap))
+		return NULL;
+	return rt_addr_ifa_flags_strmap[value];
+}
+
+/* Policies */
+const struct ynl_policy_attr rt_addr_addr_attrs_policy[IFA_MAX + 1] = {
+	[IFA_ADDRESS] = { .name = "address", .type = YNL_PT_BINARY,},
+	[IFA_LOCAL] = { .name = "local", .type = YNL_PT_BINARY,},
+	[IFA_LABEL] = { .name = "label", .type = YNL_PT_NUL_STR, },
+	[IFA_BROADCAST] = { .name = "broadcast", .type = YNL_PT_BINARY,},
+	[IFA_ANYCAST] = { .name = "anycast", .type = YNL_PT_BINARY,},
+	[IFA_CACHEINFO] = { .name = "cacheinfo", .type = YNL_PT_BINARY,},
+	[IFA_MULTICAST] = { .name = "multicast", .type = YNL_PT_BINARY,},
+	[IFA_FLAGS] = { .name = "flags", .type = YNL_PT_U32, },
+	[IFA_RT_PRIORITY] = { .name = "rt-priority", .type = YNL_PT_U32, },
+	[IFA_TARGET_NETNSID] = { .name = "target-netnsid", .type = YNL_PT_BINARY,},
+	[IFA_PROTO] = { .name = "proto", .type = YNL_PT_U8, },
+};
+
+const struct ynl_policy_nest rt_addr_addr_attrs_nest = {
+	.max_attr = IFA_MAX,
+	.table = rt_addr_addr_attrs_policy,
+};
+
+/* Common nested types */
+/* ============== RTM_NEWADDR ============== */
+/* RTM_NEWADDR - do */
+void rt_addr_newaddr_req_free(struct rt_addr_newaddr_req *req)
+{
+	free(req->address);
+	free(req->label);
+	free(req->local);
+	free(req->cacheinfo);
+	free(req);
+}
+
+int rt_addr_newaddr(struct ynl_sock *ys, struct rt_addr_newaddr_req *req)
+{
+	struct ynl_req_state yrs = { .yarg = { .ys = ys, }, };
+	struct nlmsghdr *nlh;
+	size_t hdr_len;
+	void *hdr;
+	int err;
+
+	nlh = ynl_msg_start_req(ys, RTM_NEWADDR);
+	ys->req_policy = &rt_addr_addr_attrs_nest;
+
+	hdr_len = sizeof(req->_hdr);
+	hdr = ynl_nlmsg_put_extra_header(nlh, hdr_len);
+	memcpy(hdr, &req->_hdr, hdr_len);
+
+	if (req->_present.address_len)
+		ynl_attr_put(nlh, IFA_ADDRESS, req->address, req->_present.address_len);
+	if (req->_present.label_len)
+		ynl_attr_put_str(nlh, IFA_LABEL, req->label);
+	if (req->_present.local_len)
+		ynl_attr_put(nlh, IFA_LOCAL, req->local, req->_present.local_len);
+	if (req->_present.cacheinfo_len)
+		ynl_attr_put(nlh, IFA_CACHEINFO, req->cacheinfo, req->_present.cacheinfo_len);
+
+	err = ynl_exec(ys, nlh, &yrs);
+	if (err < 0)
+		return -1;
+
+	return 0;
+}
+
+/* ============== RTM_DELADDR ============== */
+/* RTM_DELADDR - do */
+void rt_addr_deladdr_req_free(struct rt_addr_deladdr_req *req)
+{
+	free(req->address);
+	free(req->local);
+	free(req);
+}
+
+int rt_addr_deladdr(struct ynl_sock *ys, struct rt_addr_deladdr_req *req)
+{
+	struct ynl_req_state yrs = { .yarg = { .ys = ys, }, };
+	struct nlmsghdr *nlh;
+	size_t hdr_len;
+	void *hdr;
+	int err;
+
+	nlh = ynl_msg_start_req(ys, RTM_DELADDR);
+	ys->req_policy = &rt_addr_addr_attrs_nest;
+
+	hdr_len = sizeof(req->_hdr);
+	hdr = ynl_nlmsg_put_extra_header(nlh, hdr_len);
+	memcpy(hdr, &req->_hdr, hdr_len);
+
+	if (req->_present.address_len)
+		ynl_attr_put(nlh, IFA_ADDRESS, req->address, req->_present.address_len);
+	if (req->_present.local_len)
+		ynl_attr_put(nlh, IFA_LOCAL, req->local, req->_present.local_len);
+
+	err = ynl_exec(ys, nlh, &yrs);
+	if (err < 0)
+		return -1;
+
+	return 0;
+}
+
+/* ============== RTM_GETADDR ============== */
+/* RTM_GETADDR - dump */
+int rt_addr_getaddr_rsp_parse(const struct nlmsghdr *nlh,
+			      struct ynl_parse_arg *yarg)
+{
+	struct rt_addr_getaddr_rsp *dst;
+	const struct nlattr *attr;
+	void *hdr;
+
+	dst = yarg->data;
+
+	hdr = ynl_nlmsg_data(nlh);
+	memcpy(&dst->_hdr, hdr, sizeof(struct ifaddrmsg));
+
+	ynl_attr_for_each(attr, nlh, yarg->ys->family->hdr_len) {
+		unsigned int type = ynl_attr_type(attr);
+
+		if (type == IFA_ADDRESS) {
+			unsigned int len;
+
+			if (ynl_attr_validate(yarg, attr))
+				return YNL_PARSE_CB_ERROR;
+
+			len = ynl_attr_data_len(attr);
+			dst->_present.address_len = len;
+			dst->address = malloc(len);
+			memcpy(dst->address, ynl_attr_data(attr), len);
+		} else if (type == IFA_LABEL) {
+			unsigned int len;
+
+			if (ynl_attr_validate(yarg, attr))
+				return YNL_PARSE_CB_ERROR;
+
+			len = strnlen(ynl_attr_get_str(attr), ynl_attr_data_len(attr));
+			dst->_present.label_len = len;
+			dst->label = malloc(len + 1);
+			memcpy(dst->label, ynl_attr_get_str(attr), len);
+			dst->label[len] = 0;
+		} else if (type == IFA_LOCAL) {
+			unsigned int len;
+
+			if (ynl_attr_validate(yarg, attr))
+				return YNL_PARSE_CB_ERROR;
+
+			len = ynl_attr_data_len(attr);
+			dst->_present.local_len = len;
+			dst->local = malloc(len);
+			memcpy(dst->local, ynl_attr_data(attr), len);
+		} else if (type == IFA_CACHEINFO) {
+			unsigned int len;
+
+			if (ynl_attr_validate(yarg, attr))
+				return YNL_PARSE_CB_ERROR;
+
+			len = ynl_attr_data_len(attr);
+			dst->_present.cacheinfo_len = len;
+			dst->cacheinfo = malloc(len);
+			memcpy(dst->cacheinfo, ynl_attr_data(attr), len);
+		}
+	}
+
+	return YNL_PARSE_CB_OK;
+}
+
+void rt_addr_getaddr_req_free(struct rt_addr_getaddr_req *req)
+{
+	free(req);
+}
+
+void rt_addr_getaddr_list_free(struct rt_addr_getaddr_list *rsp)
+{
+	struct rt_addr_getaddr_list *next = rsp;
+
+	while ((void *)next != YNL_LIST_END) {
+		rsp = next;
+		next = rsp->next;
+
+		free(rsp->obj.address);
+		free(rsp->obj.label);
+		free(rsp->obj.local);
+		free(rsp->obj.cacheinfo);
+		free(rsp);
+	}
+}
+
+struct rt_addr_getaddr_list *
+rt_addr_getaddr_dump(struct ynl_sock *ys, struct rt_addr_getaddr_req *req)
+{
+	struct ynl_dump_state yds = {};
+	struct nlmsghdr *nlh;
+	size_t hdr_len;
+	void *hdr;
+	int err;
+
+	yds.yarg.ys = ys;
+	yds.yarg.rsp_policy = &rt_addr_addr_attrs_nest;
+	yds.yarg.data = NULL;
+	yds.alloc_sz = sizeof(struct rt_addr_getaddr_list);
+	yds.cb = rt_addr_getaddr_rsp_parse;
+	yds.rsp_cmd = 20;
+
+	nlh = ynl_msg_start_dump(ys, RTM_GETADDR);
+	hdr_len = sizeof(req->_hdr);
+	hdr = ynl_nlmsg_put_extra_header(nlh, hdr_len);
+	memcpy(hdr, &req->_hdr, hdr_len);
+
+	ys->req_policy = &rt_addr_addr_attrs_nest;
+
+	err = ynl_exec_dump(ys, nlh, &yds);
+	if (err < 0)
+		goto free_list;
+
+	return yds.first;
+
+free_list:
+	rt_addr_getaddr_list_free(yds.first);
+	return NULL;
+}
+
+/* ============== RTM_GETMULTICAST ============== */
+/* RTM_GETMULTICAST - do */
+void rt_addr_getmulticast_req_free(struct rt_addr_getmulticast_req *req)
+{
+	free(req);
+}
+
+void rt_addr_getmulticast_rsp_free(struct rt_addr_getmulticast_rsp *rsp)
+{
+	free(rsp->multicast);
+	free(rsp->cacheinfo);
+	free(rsp);
+}
+
+int rt_addr_getmulticast_rsp_parse(const struct nlmsghdr *nlh,
+				   struct ynl_parse_arg *yarg)
+{
+	struct rt_addr_getmulticast_rsp *dst;
+	const struct nlattr *attr;
+	void *hdr;
+
+	dst = yarg->data;
+
+	hdr = ynl_nlmsg_data(nlh);
+	memcpy(&dst->_hdr, hdr, sizeof(struct ifaddrmsg));
+
+	ynl_attr_for_each(attr, nlh, yarg->ys->family->hdr_len) {
+		unsigned int type = ynl_attr_type(attr);
+
+		if (type == IFA_MULTICAST) {
+			unsigned int len;
+
+			if (ynl_attr_validate(yarg, attr))
+				return YNL_PARSE_CB_ERROR;
+
+			len = ynl_attr_data_len(attr);
+			dst->_present.multicast_len = len;
+			dst->multicast = malloc(len);
+			memcpy(dst->multicast, ynl_attr_data(attr), len);
+		} else if (type == IFA_CACHEINFO) {
+			unsigned int len;
+
+			if (ynl_attr_validate(yarg, attr))
+				return YNL_PARSE_CB_ERROR;
+
+			len = ynl_attr_data_len(attr);
+			dst->_present.cacheinfo_len = len;
+			dst->cacheinfo = malloc(len);
+			memcpy(dst->cacheinfo, ynl_attr_data(attr), len);
+		}
+	}
+
+	return YNL_PARSE_CB_OK;
+}
+
+struct rt_addr_getmulticast_rsp *
+rt_addr_getmulticast(struct ynl_sock *ys, struct rt_addr_getmulticast_req *req)
+{
+	struct ynl_req_state yrs = { .yarg = { .ys = ys, }, };
+	struct rt_addr_getmulticast_rsp *rsp;
+	struct nlmsghdr *nlh;
+	size_t hdr_len;
+	void *hdr;
+	int err;
+
+	nlh = ynl_msg_start_req(ys, RTM_GETMULTICAST);
+	ys->req_policy = &rt_addr_addr_attrs_nest;
+	yrs.yarg.rsp_policy = &rt_addr_addr_attrs_nest;
+
+	hdr_len = sizeof(req->_hdr);
+	hdr = ynl_nlmsg_put_extra_header(nlh, hdr_len);
+	memcpy(hdr, &req->_hdr, hdr_len);
+
+	rsp = calloc(1, sizeof(*rsp));
+	yrs.yarg.data = rsp;
+	yrs.cb = rt_addr_getmulticast_rsp_parse;
+	yrs.rsp_cmd = RTM_GETMULTICAST;
+
+	err = ynl_exec(ys, nlh, &yrs);
+	if (err < 0)
+		goto err_free;
+
+	return rsp;
+
+err_free:
+	rt_addr_getmulticast_rsp_free(rsp);
+	return NULL;
+}
+
+/* RTM_GETMULTICAST - dump */
+void
+rt_addr_getmulticast_req_dump_free(struct rt_addr_getmulticast_req_dump *req)
+{
+	free(req);
+}
+
+void rt_addr_getmulticast_list_free(struct rt_addr_getmulticast_list *rsp)
+{
+	struct rt_addr_getmulticast_list *next = rsp;
+
+	while ((void *)next != YNL_LIST_END) {
+		rsp = next;
+		next = rsp->next;
+
+		free(rsp->obj.multicast);
+		free(rsp->obj.cacheinfo);
+		free(rsp);
+	}
+}
+
+struct rt_addr_getmulticast_list *
+rt_addr_getmulticast_dump(struct ynl_sock *ys,
+			  struct rt_addr_getmulticast_req_dump *req)
+{
+	struct ynl_dump_state yds = {};
+	struct nlmsghdr *nlh;
+	size_t hdr_len;
+	void *hdr;
+	int err;
+
+	yds.yarg.ys = ys;
+	yds.yarg.rsp_policy = &rt_addr_addr_attrs_nest;
+	yds.yarg.data = NULL;
+	yds.alloc_sz = sizeof(struct rt_addr_getmulticast_list);
+	yds.cb = rt_addr_getmulticast_rsp_parse;
+	yds.rsp_cmd = RTM_GETMULTICAST;
+
+	nlh = ynl_msg_start_dump(ys, RTM_GETMULTICAST);
+	hdr_len = sizeof(req->_hdr);
+	hdr = ynl_nlmsg_put_extra_header(nlh, hdr_len);
+	memcpy(hdr, &req->_hdr, hdr_len);
+
+	ys->req_policy = &rt_addr_addr_attrs_nest;
+
+	err = ynl_exec_dump(ys, nlh, &yds);
+	if (err < 0)
+		goto free_list;
+
+	return yds.first;
+
+free_list:
+	rt_addr_getmulticast_list_free(yds.first);
+	return NULL;
+}
+
+const struct ynl_family ynl_rt_addr_family =  {
+	.name		= "rt_addr",
+	.is_classic	= true,
+	.classic_id	= 0,
+	.hdr_len	= sizeof(struct ifaddrmsg),
+};
diff --git a/home/nipa/nipa_out/951794/ynl/new-code/rt-addr-user.h b/home/nipa/nipa_out/951794/ynl/new-code/rt-addr-user.h
new file mode 100644
index 000000000000..37df6d0e0a36
--- /dev/null
+++ b/home/nipa/nipa_out/951794/ynl/new-code/rt-addr-user.h
@@ -0,0 +1,229 @@
+/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) */
+/* Do not edit directly, auto-generated from: */
+/*	Documentation/netlink/specs/rt-addr.yaml */
+/* YNL-GEN user header */
+
+#ifndef _LINUX_RT_ADDR_GEN_H
+#define _LINUX_RT_ADDR_GEN_H
+
+#include <stdlib.h>
+#include <string.h>
+#include <linux/types.h>
+#include <linux/rtnetlink.h>
+
+struct ynl_sock;
+
+extern const struct ynl_family ynl_rt_addr_family;
+
+/* Enums */
+const char *rt_addr_op_str(int op);
+const char *rt_addr_ifa_flags_str(int value);
+
+/* Common nested types */
+/* ============== RTM_NEWADDR ============== */
+/* RTM_NEWADDR - do */
+struct rt_addr_newaddr_req {
+	struct ifaddrmsg _hdr;
+
+	struct {
+		__u32 address_len;
+		__u32 label_len;
+		__u32 local_len;
+		__u32 cacheinfo_len;
+	} _present;
+
+	void *address;
+	char *label;
+	void *local;
+	void *cacheinfo;
+};
+
+static inline struct rt_addr_newaddr_req *rt_addr_newaddr_req_alloc(void)
+{
+	return calloc(1, sizeof(struct rt_addr_newaddr_req));
+}
+void rt_addr_newaddr_req_free(struct rt_addr_newaddr_req *req);
+
+static inline void
+rt_addr_newaddr_req_set_address(struct rt_addr_newaddr_req *req,
+				const void *address, size_t len)
+{
+	free(req->address);
+	req->_present.address_len = len;
+	req->address = malloc(req->_present.address_len);
+	memcpy(req->address, address, req->_present.address_len);
+}
+static inline void
+rt_addr_newaddr_req_set_label(struct rt_addr_newaddr_req *req,
+			      const char *label)
+{
+	free(req->label);
+	req->_present.label_len = strlen(label);
+	req->label = malloc(req->_present.label_len + 1);
+	memcpy(req->label, label, req->_present.label_len);
+	req->label[req->_present.label_len] = 0;
+}
+static inline void
+rt_addr_newaddr_req_set_local(struct rt_addr_newaddr_req *req,
+			      const void *local, size_t len)
+{
+	free(req->local);
+	req->_present.local_len = len;
+	req->local = malloc(req->_present.local_len);
+	memcpy(req->local, local, req->_present.local_len);
+}
+static inline void
+rt_addr_newaddr_req_set_cacheinfo(struct rt_addr_newaddr_req *req,
+				  const void *cacheinfo, size_t len)
+{
+	free(req->cacheinfo);
+	req->_present.cacheinfo_len = len;
+	req->cacheinfo = malloc(req->_present.cacheinfo_len);
+	memcpy(req->cacheinfo, cacheinfo, req->_present.cacheinfo_len);
+}
+
+/*
+ * Add new address
+ */
+int rt_addr_newaddr(struct ynl_sock *ys, struct rt_addr_newaddr_req *req);
+
+/* ============== RTM_DELADDR ============== */
+/* RTM_DELADDR - do */
+struct rt_addr_deladdr_req {
+	struct ifaddrmsg _hdr;
+
+	struct {
+		__u32 address_len;
+		__u32 local_len;
+	} _present;
+
+	void *address;
+	void *local;
+};
+
+static inline struct rt_addr_deladdr_req *rt_addr_deladdr_req_alloc(void)
+{
+	return calloc(1, sizeof(struct rt_addr_deladdr_req));
+}
+void rt_addr_deladdr_req_free(struct rt_addr_deladdr_req *req);
+
+static inline void
+rt_addr_deladdr_req_set_address(struct rt_addr_deladdr_req *req,
+				const void *address, size_t len)
+{
+	free(req->address);
+	req->_present.address_len = len;
+	req->address = malloc(req->_present.address_len);
+	memcpy(req->address, address, req->_present.address_len);
+}
+static inline void
+rt_addr_deladdr_req_set_local(struct rt_addr_deladdr_req *req,
+			      const void *local, size_t len)
+{
+	free(req->local);
+	req->_present.local_len = len;
+	req->local = malloc(req->_present.local_len);
+	memcpy(req->local, local, req->_present.local_len);
+}
+
+/*
+ * Remove address
+ */
+int rt_addr_deladdr(struct ynl_sock *ys, struct rt_addr_deladdr_req *req);
+
+/* ============== RTM_GETADDR ============== */
+/* RTM_GETADDR - dump */
+struct rt_addr_getaddr_req {
+	struct ifaddrmsg _hdr;
+};
+
+static inline struct rt_addr_getaddr_req *rt_addr_getaddr_req_alloc(void)
+{
+	return calloc(1, sizeof(struct rt_addr_getaddr_req));
+}
+void rt_addr_getaddr_req_free(struct rt_addr_getaddr_req *req);
+
+struct rt_addr_getaddr_rsp {
+	struct ifaddrmsg _hdr;
+
+	struct {
+		__u32 address_len;
+		__u32 label_len;
+		__u32 local_len;
+		__u32 cacheinfo_len;
+	} _present;
+
+	void *address;
+	char *label;
+	void *local;
+	void *cacheinfo;
+};
+
+struct rt_addr_getaddr_list {
+	struct rt_addr_getaddr_list *next;
+	struct rt_addr_getaddr_rsp obj __attribute__((aligned(8)));
+};
+
+void rt_addr_getaddr_list_free(struct rt_addr_getaddr_list *rsp);
+
+struct rt_addr_getaddr_list *
+rt_addr_getaddr_dump(struct ynl_sock *ys, struct rt_addr_getaddr_req *req);
+
+/* ============== RTM_GETMULTICAST ============== */
+/* RTM_GETMULTICAST - do */
+struct rt_addr_getmulticast_req {
+	struct ifaddrmsg _hdr;
+};
+
+static inline struct rt_addr_getmulticast_req *
+rt_addr_getmulticast_req_alloc(void)
+{
+	return calloc(1, sizeof(struct rt_addr_getmulticast_req));
+}
+void rt_addr_getmulticast_req_free(struct rt_addr_getmulticast_req *req);
+
+struct rt_addr_getmulticast_rsp {
+	struct ifaddrmsg _hdr;
+
+	struct {
+		__u32 multicast_len;
+		__u32 cacheinfo_len;
+	} _present;
+
+	void *multicast;
+	void *cacheinfo;
+};
+
+void rt_addr_getmulticast_rsp_free(struct rt_addr_getmulticast_rsp *rsp);
+
+/*
+ * Get / dump IPv4/IPv6 multicast addresses.
+ */
+struct rt_addr_getmulticast_rsp *
+rt_addr_getmulticast(struct ynl_sock *ys, struct rt_addr_getmulticast_req *req);
+
+/* RTM_GETMULTICAST - dump */
+struct rt_addr_getmulticast_req_dump {
+	struct ifaddrmsg _hdr;
+};
+
+static inline struct rt_addr_getmulticast_req_dump *
+rt_addr_getmulticast_req_dump_alloc(void)
+{
+	return calloc(1, sizeof(struct rt_addr_getmulticast_req_dump));
+}
+void
+rt_addr_getmulticast_req_dump_free(struct rt_addr_getmulticast_req_dump *req);
+
+struct rt_addr_getmulticast_list {
+	struct rt_addr_getmulticast_list *next;
+	struct rt_addr_getmulticast_rsp obj __attribute__((aligned(8)));
+};
+
+void rt_addr_getmulticast_list_free(struct rt_addr_getmulticast_list *rsp);
+
+struct rt_addr_getmulticast_list *
+rt_addr_getmulticast_dump(struct ynl_sock *ys,
+			  struct rt_addr_getmulticast_req_dump *req);
+
+#endif /* _LINUX_RT_ADDR_GEN_H */
diff --git a/home/nipa/nipa_out/951794/ynl/new-code/rt-route-user.c b/home/nipa/nipa_out/951794/ynl/new-code/rt-route-user.c
new file mode 100644
index 000000000000..5ef002be36ac
--- /dev/null
+++ b/home/nipa/nipa_out/951794/ynl/new-code/rt-route-user.c
@@ -0,0 +1,840 @@
+// SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause)
+/* Do not edit directly, auto-generated from: */
+/*	Documentation/netlink/specs/rt-route.yaml */
+/* YNL-GEN user source */
+
+#include <stdlib.h>
+#include <string.h>
+#include "rt-route-user.h"
+#include "ynl.h"
+#include <linux/rtnetlink.h>
+
+#include <linux/genetlink.h>
+
+/* Enums */
+static const char * const rt_route_op_strmap[] = {
+	[24] = "getroute",
+};
+
+const char *rt_route_op_str(int op)
+{
+	if (op < 0 || op >= (int)YNL_ARRAY_SIZE(rt_route_op_strmap))
+		return NULL;
+	return rt_route_op_strmap[op];
+}
+
+static const char * const rt_route_rtm_type_strmap[] = {
+	[0] = "unspec",
+	[1] = "unicast",
+	[2] = "local",
+	[3] = "broadcast",
+	[4] = "anycast",
+	[5] = "multicast",
+	[6] = "blackhole",
+	[7] = "unreachable",
+	[8] = "prohibit",
+	[9] = "throw",
+	[10] = "nat",
+	[11] = "xresolve",
+};
+
+const char *rt_route_rtm_type_str(int value)
+{
+	if (value < 0 || value >= (int)YNL_ARRAY_SIZE(rt_route_rtm_type_strmap))
+		return NULL;
+	return rt_route_rtm_type_strmap[value];
+}
+
+/* Policies */
+const struct ynl_policy_attr rt_route_metrics_policy[RTAX_MAX + 1] = {
+	[RTAX_UNSPEC] = { .name = "unspec", .type = YNL_PT_REJECT, },
+	[RTAX_LOCK] = { .name = "lock", .type = YNL_PT_U32, },
+	[RTAX_MTU] = { .name = "mtu", .type = YNL_PT_U32, },
+	[RTAX_WINDOW] = { .name = "window", .type = YNL_PT_U32, },
+	[RTAX_RTT] = { .name = "rtt", .type = YNL_PT_U32, },
+	[RTAX_RTTVAR] = { .name = "rttvar", .type = YNL_PT_U32, },
+	[RTAX_SSTHRESH] = { .name = "ssthresh", .type = YNL_PT_U32, },
+	[RTAX_CWND] = { .name = "cwnd", .type = YNL_PT_U32, },
+	[RTAX_ADVMSS] = { .name = "advmss", .type = YNL_PT_U32, },
+	[RTAX_REORDERING] = { .name = "reordering", .type = YNL_PT_U32, },
+	[RTAX_HOPLIMIT] = { .name = "hoplimit", .type = YNL_PT_U32, },
+	[RTAX_INITCWND] = { .name = "initcwnd", .type = YNL_PT_U32, },
+	[RTAX_FEATURES] = { .name = "features", .type = YNL_PT_U32, },
+	[RTAX_RTO_MIN] = { .name = "rto-min", .type = YNL_PT_U32, },
+	[RTAX_INITRWND] = { .name = "initrwnd", .type = YNL_PT_U32, },
+	[RTAX_QUICKACK] = { .name = "quickack", .type = YNL_PT_U32, },
+	[RTAX_CC_ALGO] = { .name = "cc-algo", .type = YNL_PT_NUL_STR, },
+	[RTAX_FASTOPEN_NO_COOKIE] = { .name = "fastopen-no-cookie", .type = YNL_PT_U32, },
+};
+
+const struct ynl_policy_nest rt_route_metrics_nest = {
+	.max_attr = RTAX_MAX,
+	.table = rt_route_metrics_policy,
+};
+
+const struct ynl_policy_attr rt_route_route_attrs_policy[RTA_MAX + 1] = {
+	[RTA_DST] = { .name = "dst", .type = YNL_PT_BINARY,},
+	[RTA_SRC] = { .name = "src", .type = YNL_PT_BINARY,},
+	[RTA_IIF] = { .name = "iif", .type = YNL_PT_U32, },
+	[RTA_OIF] = { .name = "oif", .type = YNL_PT_U32, },
+	[RTA_GATEWAY] = { .name = "gateway", .type = YNL_PT_BINARY,},
+	[RTA_PRIORITY] = { .name = "priority", .type = YNL_PT_U32, },
+	[RTA_PREFSRC] = { .name = "prefsrc", .type = YNL_PT_BINARY,},
+	[RTA_METRICS] = { .name = "metrics", .type = YNL_PT_NEST, .nest = &rt_route_metrics_nest, },
+	[RTA_MULTIPATH] = { .name = "multipath", .type = YNL_PT_BINARY,},
+	[RTA_PROTOINFO] = { .name = "protoinfo", .type = YNL_PT_BINARY,},
+	[RTA_FLOW] = { .name = "flow", .type = YNL_PT_U32, },
+	[RTA_CACHEINFO] = { .name = "cacheinfo", .type = YNL_PT_BINARY,},
+	[RTA_SESSION] = { .name = "session", .type = YNL_PT_BINARY,},
+	[RTA_MP_ALGO] = { .name = "mp-algo", .type = YNL_PT_BINARY,},
+	[RTA_TABLE] = { .name = "table", .type = YNL_PT_U32, },
+	[RTA_MARK] = { .name = "mark", .type = YNL_PT_U32, },
+	[RTA_MFC_STATS] = { .name = "mfc-stats", .type = YNL_PT_BINARY,},
+	[RTA_VIA] = { .name = "via", .type = YNL_PT_BINARY,},
+	[RTA_NEWDST] = { .name = "newdst", .type = YNL_PT_BINARY,},
+	[RTA_PREF] = { .name = "pref", .type = YNL_PT_U8, },
+	[RTA_ENCAP_TYPE] = { .name = "encap-type", .type = YNL_PT_U16, },
+	[RTA_ENCAP] = { .name = "encap", .type = YNL_PT_BINARY,},
+	[RTA_EXPIRES] = { .name = "expires", .type = YNL_PT_U32, },
+	[RTA_PAD] = { .name = "pad", .type = YNL_PT_BINARY,},
+	[RTA_UID] = { .name = "uid", .type = YNL_PT_U32, },
+	[RTA_TTL_PROPAGATE] = { .name = "ttl-propagate", .type = YNL_PT_U8, },
+	[RTA_IP_PROTO] = { .name = "ip-proto", .type = YNL_PT_U8, },
+	[RTA_SPORT] = { .name = "sport", .type = YNL_PT_U16, },
+	[RTA_DPORT] = { .name = "dport", .type = YNL_PT_U16, },
+	[RTA_NH_ID] = { .name = "nh-id", .type = YNL_PT_U32, },
+	[RTA_FLOWLABEL] = { .name = "flowlabel", .type = YNL_PT_U32, },
+};
+
+const struct ynl_policy_nest rt_route_route_attrs_nest = {
+	.max_attr = RTA_MAX,
+	.table = rt_route_route_attrs_policy,
+};
+
+/* Common nested types */
+void rt_route_metrics_free(struct rt_route_metrics *obj)
+{
+	free(obj->cc_algo);
+}
+
+int rt_route_metrics_put(struct nlmsghdr *nlh, unsigned int attr_type,
+			 struct rt_route_metrics *obj)
+{
+	struct nlattr *nest;
+
+	nest = ynl_attr_nest_start(nlh, attr_type);
+	if (obj->_present.lock)
+		ynl_attr_put_u32(nlh, RTAX_LOCK, obj->lock);
+	if (obj->_present.mtu)
+		ynl_attr_put_u32(nlh, RTAX_MTU, obj->mtu);
+	if (obj->_present.window)
+		ynl_attr_put_u32(nlh, RTAX_WINDOW, obj->window);
+	if (obj->_present.rtt)
+		ynl_attr_put_u32(nlh, RTAX_RTT, obj->rtt);
+	if (obj->_present.rttvar)
+		ynl_attr_put_u32(nlh, RTAX_RTTVAR, obj->rttvar);
+	if (obj->_present.ssthresh)
+		ynl_attr_put_u32(nlh, RTAX_SSTHRESH, obj->ssthresh);
+	if (obj->_present.cwnd)
+		ynl_attr_put_u32(nlh, RTAX_CWND, obj->cwnd);
+	if (obj->_present.advmss)
+		ynl_attr_put_u32(nlh, RTAX_ADVMSS, obj->advmss);
+	if (obj->_present.reordering)
+		ynl_attr_put_u32(nlh, RTAX_REORDERING, obj->reordering);
+	if (obj->_present.hoplimit)
+		ynl_attr_put_u32(nlh, RTAX_HOPLIMIT, obj->hoplimit);
+	if (obj->_present.initcwnd)
+		ynl_attr_put_u32(nlh, RTAX_INITCWND, obj->initcwnd);
+	if (obj->_present.features)
+		ynl_attr_put_u32(nlh, RTAX_FEATURES, obj->features);
+	if (obj->_present.rto_min)
+		ynl_attr_put_u32(nlh, RTAX_RTO_MIN, obj->rto_min);
+	if (obj->_present.initrwnd)
+		ynl_attr_put_u32(nlh, RTAX_INITRWND, obj->initrwnd);
+	if (obj->_present.quickack)
+		ynl_attr_put_u32(nlh, RTAX_QUICKACK, obj->quickack);
+	if (obj->_present.cc_algo_len)
+		ynl_attr_put_str(nlh, RTAX_CC_ALGO, obj->cc_algo);
+	if (obj->_present.fastopen_no_cookie)
+		ynl_attr_put_u32(nlh, RTAX_FASTOPEN_NO_COOKIE, obj->fastopen_no_cookie);
+	ynl_attr_nest_end(nlh, nest);
+
+	return 0;
+}
+
+int rt_route_metrics_parse(struct ynl_parse_arg *yarg,
+			   const struct nlattr *nested)
+{
+	struct rt_route_metrics *dst = yarg->data;
+	const struct nlattr *attr;
+
+	ynl_attr_for_each_nested(attr, nested) {
+		unsigned int type = ynl_attr_type(attr);
+
+		if (type == RTAX_LOCK) {
+			if (ynl_attr_validate(yarg, attr))
+				return YNL_PARSE_CB_ERROR;
+			dst->_present.lock = 1;
+			dst->lock = ynl_attr_get_u32(attr);
+		} else if (type == RTAX_MTU) {
+			if (ynl_attr_validate(yarg, attr))
+				return YNL_PARSE_CB_ERROR;
+			dst->_present.mtu = 1;
+			dst->mtu = ynl_attr_get_u32(attr);
+		} else if (type == RTAX_WINDOW) {
+			if (ynl_attr_validate(yarg, attr))
+				return YNL_PARSE_CB_ERROR;
+			dst->_present.window = 1;
+			dst->window = ynl_attr_get_u32(attr);
+		} else if (type == RTAX_RTT) {
+			if (ynl_attr_validate(yarg, attr))
+				return YNL_PARSE_CB_ERROR;
+			dst->_present.rtt = 1;
+			dst->rtt = ynl_attr_get_u32(attr);
+		} else if (type == RTAX_RTTVAR) {
+			if (ynl_attr_validate(yarg, attr))
+				return YNL_PARSE_CB_ERROR;
+			dst->_present.rttvar = 1;
+			dst->rttvar = ynl_attr_get_u32(attr);
+		} else if (type == RTAX_SSTHRESH) {
+			if (ynl_attr_validate(yarg, attr))
+				return YNL_PARSE_CB_ERROR;
+			dst->_present.ssthresh = 1;
+			dst->ssthresh = ynl_attr_get_u32(attr);
+		} else if (type == RTAX_CWND) {
+			if (ynl_attr_validate(yarg, attr))
+				return YNL_PARSE_CB_ERROR;
+			dst->_present.cwnd = 1;
+			dst->cwnd = ynl_attr_get_u32(attr);
+		} else if (type == RTAX_ADVMSS) {
+			if (ynl_attr_validate(yarg, attr))
+				return YNL_PARSE_CB_ERROR;
+			dst->_present.advmss = 1;
+			dst->advmss = ynl_attr_get_u32(attr);
+		} else if (type == RTAX_REORDERING) {
+			if (ynl_attr_validate(yarg, attr))
+				return YNL_PARSE_CB_ERROR;
+			dst->_present.reordering = 1;
+			dst->reordering = ynl_attr_get_u32(attr);
+		} else if (type == RTAX_HOPLIMIT) {
+			if (ynl_attr_validate(yarg, attr))
+				return YNL_PARSE_CB_ERROR;
+			dst->_present.hoplimit = 1;
+			dst->hoplimit = ynl_attr_get_u32(attr);
+		} else if (type == RTAX_INITCWND) {
+			if (ynl_attr_validate(yarg, attr))
+				return YNL_PARSE_CB_ERROR;
+			dst->_present.initcwnd = 1;
+			dst->initcwnd = ynl_attr_get_u32(attr);
+		} else if (type == RTAX_FEATURES) {
+			if (ynl_attr_validate(yarg, attr))
+				return YNL_PARSE_CB_ERROR;
+			dst->_present.features = 1;
+			dst->features = ynl_attr_get_u32(attr);
+		} else if (type == RTAX_RTO_MIN) {
+			if (ynl_attr_validate(yarg, attr))
+				return YNL_PARSE_CB_ERROR;
+			dst->_present.rto_min = 1;
+			dst->rto_min = ynl_attr_get_u32(attr);
+		} else if (type == RTAX_INITRWND) {
+			if (ynl_attr_validate(yarg, attr))
+				return YNL_PARSE_CB_ERROR;
+			dst->_present.initrwnd = 1;
+			dst->initrwnd = ynl_attr_get_u32(attr);
+		} else if (type == RTAX_QUICKACK) {
+			if (ynl_attr_validate(yarg, attr))
+				return YNL_PARSE_CB_ERROR;
+			dst->_present.quickack = 1;
+			dst->quickack = ynl_attr_get_u32(attr);
+		} else if (type == RTAX_CC_ALGO) {
+			unsigned int len;
+
+			if (ynl_attr_validate(yarg, attr))
+				return YNL_PARSE_CB_ERROR;
+
+			len = strnlen(ynl_attr_get_str(attr), ynl_attr_data_len(attr));
+			dst->_present.cc_algo_len = len;
+			dst->cc_algo = malloc(len + 1);
+			memcpy(dst->cc_algo, ynl_attr_get_str(attr), len);
+			dst->cc_algo[len] = 0;
+		} else if (type == RTAX_FASTOPEN_NO_COOKIE) {
+			if (ynl_attr_validate(yarg, attr))
+				return YNL_PARSE_CB_ERROR;
+			dst->_present.fastopen_no_cookie = 1;
+			dst->fastopen_no_cookie = ynl_attr_get_u32(attr);
+		}
+	}
+
+	return 0;
+}
+
+/* ============== RTM_GETROUTE ============== */
+/* RTM_GETROUTE - do */
+void rt_route_getroute_req_free(struct rt_route_getroute_req *req)
+{
+	free(req->src);
+	free(req->dst);
+	free(req);
+}
+
+void rt_route_getroute_rsp_free(struct rt_route_getroute_rsp *rsp)
+{
+	free(rsp->dst);
+	free(rsp->src);
+	free(rsp->gateway);
+	free(rsp->prefsrc);
+	rt_route_metrics_free(&rsp->metrics);
+	free(rsp->multipath);
+	free(rsp->cacheinfo);
+	free(rsp->mfc_stats);
+	free(rsp->via);
+	free(rsp->newdst);
+	free(rsp->encap);
+	free(rsp->pad);
+	free(rsp);
+}
+
+int rt_route_getroute_rsp_parse(const struct nlmsghdr *nlh,
+				struct ynl_parse_arg *yarg)
+{
+	struct rt_route_getroute_rsp *dst;
+	const struct nlattr *attr;
+	struct ynl_parse_arg parg;
+	void *hdr;
+
+	dst = yarg->data;
+	parg.ys = yarg->ys;
+
+	hdr = ynl_nlmsg_data(nlh);
+	memcpy(&dst->_hdr, hdr, sizeof(struct rtmsg));
+
+	ynl_attr_for_each(attr, nlh, yarg->ys->family->hdr_len) {
+		unsigned int type = ynl_attr_type(attr);
+
+		if (type == RTA_DST) {
+			unsigned int len;
+
+			if (ynl_attr_validate(yarg, attr))
+				return YNL_PARSE_CB_ERROR;
+
+			len = ynl_attr_data_len(attr);
+			dst->_present.dst_len = len;
+			dst->dst = malloc(len);
+			memcpy(dst->dst, ynl_attr_data(attr), len);
+		} else if (type == RTA_SRC) {
+			unsigned int len;
+
+			if (ynl_attr_validate(yarg, attr))
+				return YNL_PARSE_CB_ERROR;
+
+			len = ynl_attr_data_len(attr);
+			dst->_present.src_len = len;
+			dst->src = malloc(len);
+			memcpy(dst->src, ynl_attr_data(attr), len);
+		} else if (type == RTA_IIF) {
+			if (ynl_attr_validate(yarg, attr))
+				return YNL_PARSE_CB_ERROR;
+			dst->_present.iif = 1;
+			dst->iif = ynl_attr_get_u32(attr);
+		} else if (type == RTA_OIF) {
+			if (ynl_attr_validate(yarg, attr))
+				return YNL_PARSE_CB_ERROR;
+			dst->_present.oif = 1;
+			dst->oif = ynl_attr_get_u32(attr);
+		} else if (type == RTA_GATEWAY) {
+			unsigned int len;
+
+			if (ynl_attr_validate(yarg, attr))
+				return YNL_PARSE_CB_ERROR;
+
+			len = ynl_attr_data_len(attr);
+			dst->_present.gateway_len = len;
+			dst->gateway = malloc(len);
+			memcpy(dst->gateway, ynl_attr_data(attr), len);
+		} else if (type == RTA_PRIORITY) {
+			if (ynl_attr_validate(yarg, attr))
+				return YNL_PARSE_CB_ERROR;
+			dst->_present.priority = 1;
+			dst->priority = ynl_attr_get_u32(attr);
+		} else if (type == RTA_PREFSRC) {
+			unsigned int len;
+
+			if (ynl_attr_validate(yarg, attr))
+				return YNL_PARSE_CB_ERROR;
+
+			len = ynl_attr_data_len(attr);
+			dst->_present.prefsrc_len = len;
+			dst->prefsrc = malloc(len);
+			memcpy(dst->prefsrc, ynl_attr_data(attr), len);
+		} else if (type == RTA_METRICS) {
+			if (ynl_attr_validate(yarg, attr))
+				return YNL_PARSE_CB_ERROR;
+			dst->_present.metrics = 1;
+
+			parg.rsp_policy = &rt_route_metrics_nest;
+			parg.data = &dst->metrics;
+			if (rt_route_metrics_parse(&parg, attr))
+				return YNL_PARSE_CB_ERROR;
+		} else if (type == RTA_MULTIPATH) {
+			unsigned int len;
+
+			if (ynl_attr_validate(yarg, attr))
+				return YNL_PARSE_CB_ERROR;
+
+			len = ynl_attr_data_len(attr);
+			dst->_present.multipath_len = len;
+			dst->multipath = malloc(len);
+			memcpy(dst->multipath, ynl_attr_data(attr), len);
+		} else if (type == RTA_FLOW) {
+			if (ynl_attr_validate(yarg, attr))
+				return YNL_PARSE_CB_ERROR;
+			dst->_present.flow = 1;
+			dst->flow = ynl_attr_get_u32(attr);
+		} else if (type == RTA_CACHEINFO) {
+			unsigned int len;
+
+			if (ynl_attr_validate(yarg, attr))
+				return YNL_PARSE_CB_ERROR;
+
+			len = ynl_attr_data_len(attr);
+			dst->_present.cacheinfo_len = len;
+			dst->cacheinfo = malloc(len);
+			memcpy(dst->cacheinfo, ynl_attr_data(attr), len);
+		} else if (type == RTA_TABLE) {
+			if (ynl_attr_validate(yarg, attr))
+				return YNL_PARSE_CB_ERROR;
+			dst->_present.table = 1;
+			dst->table = ynl_attr_get_u32(attr);
+		} else if (type == RTA_MARK) {
+			if (ynl_attr_validate(yarg, attr))
+				return YNL_PARSE_CB_ERROR;
+			dst->_present.mark = 1;
+			dst->mark = ynl_attr_get_u32(attr);
+		} else if (type == RTA_MFC_STATS) {
+			unsigned int len;
+
+			if (ynl_attr_validate(yarg, attr))
+				return YNL_PARSE_CB_ERROR;
+
+			len = ynl_attr_data_len(attr);
+			dst->_present.mfc_stats_len = len;
+			dst->mfc_stats = malloc(len);
+			memcpy(dst->mfc_stats, ynl_attr_data(attr), len);
+		} else if (type == RTA_VIA) {
+			unsigned int len;
+
+			if (ynl_attr_validate(yarg, attr))
+				return YNL_PARSE_CB_ERROR;
+
+			len = ynl_attr_data_len(attr);
+			dst->_present.via_len = len;
+			dst->via = malloc(len);
+			memcpy(dst->via, ynl_attr_data(attr), len);
+		} else if (type == RTA_NEWDST) {
+			unsigned int len;
+
+			if (ynl_attr_validate(yarg, attr))
+				return YNL_PARSE_CB_ERROR;
+
+			len = ynl_attr_data_len(attr);
+			dst->_present.newdst_len = len;
+			dst->newdst = malloc(len);
+			memcpy(dst->newdst, ynl_attr_data(attr), len);
+		} else if (type == RTA_PREF) {
+			if (ynl_attr_validate(yarg, attr))
+				return YNL_PARSE_CB_ERROR;
+			dst->_present.pref = 1;
+			dst->pref = ynl_attr_get_u8(attr);
+		} else if (type == RTA_ENCAP_TYPE) {
+			if (ynl_attr_validate(yarg, attr))
+				return YNL_PARSE_CB_ERROR;
+			dst->_present.encap_type = 1;
+			dst->encap_type = ynl_attr_get_u16(attr);
+		} else if (type == RTA_ENCAP) {
+			unsigned int len;
+
+			if (ynl_attr_validate(yarg, attr))
+				return YNL_PARSE_CB_ERROR;
+
+			len = ynl_attr_data_len(attr);
+			dst->_present.encap_len = len;
+			dst->encap = malloc(len);
+			memcpy(dst->encap, ynl_attr_data(attr), len);
+		} else if (type == RTA_EXPIRES) {
+			if (ynl_attr_validate(yarg, attr))
+				return YNL_PARSE_CB_ERROR;
+			dst->_present.expires = 1;
+			dst->expires = ynl_attr_get_u32(attr);
+		} else if (type == RTA_PAD) {
+			unsigned int len;
+
+			if (ynl_attr_validate(yarg, attr))
+				return YNL_PARSE_CB_ERROR;
+
+			len = ynl_attr_data_len(attr);
+			dst->_present.pad_len = len;
+			dst->pad = malloc(len);
+			memcpy(dst->pad, ynl_attr_data(attr), len);
+		} else if (type == RTA_UID) {
+			if (ynl_attr_validate(yarg, attr))
+				return YNL_PARSE_CB_ERROR;
+			dst->_present.uid = 1;
+			dst->uid = ynl_attr_get_u32(attr);
+		} else if (type == RTA_TTL_PROPAGATE) {
+			if (ynl_attr_validate(yarg, attr))
+				return YNL_PARSE_CB_ERROR;
+			dst->_present.ttl_propagate = 1;
+			dst->ttl_propagate = ynl_attr_get_u8(attr);
+		} else if (type == RTA_IP_PROTO) {
+			if (ynl_attr_validate(yarg, attr))
+				return YNL_PARSE_CB_ERROR;
+			dst->_present.ip_proto = 1;
+			dst->ip_proto = ynl_attr_get_u8(attr);
+		} else if (type == RTA_SPORT) {
+			if (ynl_attr_validate(yarg, attr))
+				return YNL_PARSE_CB_ERROR;
+			dst->_present.sport = 1;
+			dst->sport = ynl_attr_get_u16(attr);
+		} else if (type == RTA_DPORT) {
+			if (ynl_attr_validate(yarg, attr))
+				return YNL_PARSE_CB_ERROR;
+			dst->_present.dport = 1;
+			dst->dport = ynl_attr_get_u16(attr);
+		} else if (type == RTA_NH_ID) {
+			if (ynl_attr_validate(yarg, attr))
+				return YNL_PARSE_CB_ERROR;
+			dst->_present.nh_id = 1;
+			dst->nh_id = ynl_attr_get_u32(attr);
+		} else if (type == RTA_FLOWLABEL) {
+			if (ynl_attr_validate(yarg, attr))
+				return YNL_PARSE_CB_ERROR;
+			dst->_present.flowlabel = 1;
+			dst->flowlabel = ynl_attr_get_u32(attr);
+		}
+	}
+
+	return YNL_PARSE_CB_OK;
+}
+
+struct rt_route_getroute_rsp *
+rt_route_getroute(struct ynl_sock *ys, struct rt_route_getroute_req *req)
+{
+	struct ynl_req_state yrs = { .yarg = { .ys = ys, }, };
+	struct rt_route_getroute_rsp *rsp;
+	struct nlmsghdr *nlh;
+	size_t hdr_len;
+	void *hdr;
+	int err;
+
+	nlh = ynl_msg_start_req(ys, RTM_GETROUTE);
+	ys->req_policy = &rt_route_route_attrs_nest;
+	yrs.yarg.rsp_policy = &rt_route_route_attrs_nest;
+
+	hdr_len = sizeof(req->_hdr);
+	hdr = ynl_nlmsg_put_extra_header(nlh, hdr_len);
+	memcpy(hdr, &req->_hdr, hdr_len);
+
+	if (req->_present.src_len)
+		ynl_attr_put(nlh, RTA_SRC, req->src, req->_present.src_len);
+	if (req->_present.dst_len)
+		ynl_attr_put(nlh, RTA_DST, req->dst, req->_present.dst_len);
+	if (req->_present.iif)
+		ynl_attr_put_u32(nlh, RTA_IIF, req->iif);
+	if (req->_present.oif)
+		ynl_attr_put_u32(nlh, RTA_OIF, req->oif);
+	if (req->_present.ip_proto)
+		ynl_attr_put_u8(nlh, RTA_IP_PROTO, req->ip_proto);
+	if (req->_present.sport)
+		ynl_attr_put_u16(nlh, RTA_SPORT, req->sport);
+	if (req->_present.dport)
+		ynl_attr_put_u16(nlh, RTA_DPORT, req->dport);
+	if (req->_present.mark)
+		ynl_attr_put_u32(nlh, RTA_MARK, req->mark);
+	if (req->_present.uid)
+		ynl_attr_put_u32(nlh, RTA_UID, req->uid);
+	if (req->_present.flowlabel)
+		ynl_attr_put_u32(nlh, RTA_FLOWLABEL, req->flowlabel);
+
+	rsp = calloc(1, sizeof(*rsp));
+	yrs.yarg.data = rsp;
+	yrs.cb = rt_route_getroute_rsp_parse;
+	yrs.rsp_cmd = 24;
+
+	err = ynl_exec(ys, nlh, &yrs);
+	if (err < 0)
+		goto err_free;
+
+	return rsp;
+
+err_free:
+	rt_route_getroute_rsp_free(rsp);
+	return NULL;
+}
+
+/* RTM_GETROUTE - dump */
+void rt_route_getroute_req_dump_free(struct rt_route_getroute_req_dump *req)
+{
+	free(req);
+}
+
+void rt_route_getroute_list_free(struct rt_route_getroute_list *rsp)
+{
+	struct rt_route_getroute_list *next = rsp;
+
+	while ((void *)next != YNL_LIST_END) {
+		rsp = next;
+		next = rsp->next;
+
+		free(rsp->obj.dst);
+		free(rsp->obj.src);
+		free(rsp->obj.gateway);
+		free(rsp->obj.prefsrc);
+		rt_route_metrics_free(&rsp->obj.metrics);
+		free(rsp->obj.multipath);
+		free(rsp->obj.cacheinfo);
+		free(rsp->obj.mfc_stats);
+		free(rsp->obj.via);
+		free(rsp->obj.newdst);
+		free(rsp->obj.encap);
+		free(rsp->obj.pad);
+		free(rsp);
+	}
+}
+
+struct rt_route_getroute_list *
+rt_route_getroute_dump(struct ynl_sock *ys,
+		       struct rt_route_getroute_req_dump *req)
+{
+	struct ynl_dump_state yds = {};
+	struct nlmsghdr *nlh;
+	size_t hdr_len;
+	void *hdr;
+	int err;
+
+	yds.yarg.ys = ys;
+	yds.yarg.rsp_policy = &rt_route_route_attrs_nest;
+	yds.yarg.data = NULL;
+	yds.alloc_sz = sizeof(struct rt_route_getroute_list);
+	yds.cb = rt_route_getroute_rsp_parse;
+	yds.rsp_cmd = 24;
+
+	nlh = ynl_msg_start_dump(ys, RTM_GETROUTE);
+	hdr_len = sizeof(req->_hdr);
+	hdr = ynl_nlmsg_put_extra_header(nlh, hdr_len);
+	memcpy(hdr, &req->_hdr, hdr_len);
+
+	ys->req_policy = &rt_route_route_attrs_nest;
+
+	err = ynl_exec_dump(ys, nlh, &yds);
+	if (err < 0)
+		goto free_list;
+
+	return yds.first;
+
+free_list:
+	rt_route_getroute_list_free(yds.first);
+	return NULL;
+}
+
+/* ============== RTM_NEWROUTE ============== */
+/* RTM_NEWROUTE - do */
+void rt_route_newroute_req_free(struct rt_route_newroute_req *req)
+{
+	free(req->dst);
+	free(req->src);
+	free(req->gateway);
+	free(req->prefsrc);
+	rt_route_metrics_free(&req->metrics);
+	free(req->multipath);
+	free(req->cacheinfo);
+	free(req->mfc_stats);
+	free(req->via);
+	free(req->newdst);
+	free(req->encap);
+	free(req->pad);
+	free(req);
+}
+
+int rt_route_newroute(struct ynl_sock *ys, struct rt_route_newroute_req *req)
+{
+	struct ynl_req_state yrs = { .yarg = { .ys = ys, }, };
+	struct nlmsghdr *nlh;
+	size_t hdr_len;
+	void *hdr;
+	int err;
+
+	nlh = ynl_msg_start_req(ys, RTM_NEWROUTE);
+	ys->req_policy = &rt_route_route_attrs_nest;
+
+	hdr_len = sizeof(req->_hdr);
+	hdr = ynl_nlmsg_put_extra_header(nlh, hdr_len);
+	memcpy(hdr, &req->_hdr, hdr_len);
+
+	if (req->_present.dst_len)
+		ynl_attr_put(nlh, RTA_DST, req->dst, req->_present.dst_len);
+	if (req->_present.src_len)
+		ynl_attr_put(nlh, RTA_SRC, req->src, req->_present.src_len);
+	if (req->_present.iif)
+		ynl_attr_put_u32(nlh, RTA_IIF, req->iif);
+	if (req->_present.oif)
+		ynl_attr_put_u32(nlh, RTA_OIF, req->oif);
+	if (req->_present.gateway_len)
+		ynl_attr_put(nlh, RTA_GATEWAY, req->gateway, req->_present.gateway_len);
+	if (req->_present.priority)
+		ynl_attr_put_u32(nlh, RTA_PRIORITY, req->priority);
+	if (req->_present.prefsrc_len)
+		ynl_attr_put(nlh, RTA_PREFSRC, req->prefsrc, req->_present.prefsrc_len);
+	if (req->_present.metrics)
+		rt_route_metrics_put(nlh, RTA_METRICS, &req->metrics);
+	if (req->_present.multipath_len)
+		ynl_attr_put(nlh, RTA_MULTIPATH, req->multipath, req->_present.multipath_len);
+	if (req->_present.flow)
+		ynl_attr_put_u32(nlh, RTA_FLOW, req->flow);
+	if (req->_present.cacheinfo_len)
+		ynl_attr_put(nlh, RTA_CACHEINFO, req->cacheinfo, req->_present.cacheinfo_len);
+	if (req->_present.table)
+		ynl_attr_put_u32(nlh, RTA_TABLE, req->table);
+	if (req->_present.mark)
+		ynl_attr_put_u32(nlh, RTA_MARK, req->mark);
+	if (req->_present.mfc_stats_len)
+		ynl_attr_put(nlh, RTA_MFC_STATS, req->mfc_stats, req->_present.mfc_stats_len);
+	if (req->_present.via_len)
+		ynl_attr_put(nlh, RTA_VIA, req->via, req->_present.via_len);
+	if (req->_present.newdst_len)
+		ynl_attr_put(nlh, RTA_NEWDST, req->newdst, req->_present.newdst_len);
+	if (req->_present.pref)
+		ynl_attr_put_u8(nlh, RTA_PREF, req->pref);
+	if (req->_present.encap_type)
+		ynl_attr_put_u16(nlh, RTA_ENCAP_TYPE, req->encap_type);
+	if (req->_present.encap_len)
+		ynl_attr_put(nlh, RTA_ENCAP, req->encap, req->_present.encap_len);
+	if (req->_present.expires)
+		ynl_attr_put_u32(nlh, RTA_EXPIRES, req->expires);
+	if (req->_present.pad_len)
+		ynl_attr_put(nlh, RTA_PAD, req->pad, req->_present.pad_len);
+	if (req->_present.uid)
+		ynl_attr_put_u32(nlh, RTA_UID, req->uid);
+	if (req->_present.ttl_propagate)
+		ynl_attr_put_u8(nlh, RTA_TTL_PROPAGATE, req->ttl_propagate);
+	if (req->_present.ip_proto)
+		ynl_attr_put_u8(nlh, RTA_IP_PROTO, req->ip_proto);
+	if (req->_present.sport)
+		ynl_attr_put_u16(nlh, RTA_SPORT, req->sport);
+	if (req->_present.dport)
+		ynl_attr_put_u16(nlh, RTA_DPORT, req->dport);
+	if (req->_present.nh_id)
+		ynl_attr_put_u32(nlh, RTA_NH_ID, req->nh_id);
+	if (req->_present.flowlabel)
+		ynl_attr_put_u32(nlh, RTA_FLOWLABEL, req->flowlabel);
+
+	err = ynl_exec(ys, nlh, &yrs);
+	if (err < 0)
+		return -1;
+
+	return 0;
+}
+
+/* ============== RTM_DELROUTE ============== */
+/* RTM_DELROUTE - do */
+void rt_route_delroute_req_free(struct rt_route_delroute_req *req)
+{
+	free(req->dst);
+	free(req->src);
+	free(req->gateway);
+	free(req->prefsrc);
+	rt_route_metrics_free(&req->metrics);
+	free(req->multipath);
+	free(req->cacheinfo);
+	free(req->mfc_stats);
+	free(req->via);
+	free(req->newdst);
+	free(req->encap);
+	free(req->pad);
+	free(req);
+}
+
+int rt_route_delroute(struct ynl_sock *ys, struct rt_route_delroute_req *req)
+{
+	struct ynl_req_state yrs = { .yarg = { .ys = ys, }, };
+	struct nlmsghdr *nlh;
+	size_t hdr_len;
+	void *hdr;
+	int err;
+
+	nlh = ynl_msg_start_req(ys, RTM_DELROUTE);
+	ys->req_policy = &rt_route_route_attrs_nest;
+
+	hdr_len = sizeof(req->_hdr);
+	hdr = ynl_nlmsg_put_extra_header(nlh, hdr_len);
+	memcpy(hdr, &req->_hdr, hdr_len);
+
+	if (req->_present.dst_len)
+		ynl_attr_put(nlh, RTA_DST, req->dst, req->_present.dst_len);
+	if (req->_present.src_len)
+		ynl_attr_put(nlh, RTA_SRC, req->src, req->_present.src_len);
+	if (req->_present.iif)
+		ynl_attr_put_u32(nlh, RTA_IIF, req->iif);
+	if (req->_present.oif)
+		ynl_attr_put_u32(nlh, RTA_OIF, req->oif);
+	if (req->_present.gateway_len)
+		ynl_attr_put(nlh, RTA_GATEWAY, req->gateway, req->_present.gateway_len);
+	if (req->_present.priority)
+		ynl_attr_put_u32(nlh, RTA_PRIORITY, req->priority);
+	if (req->_present.prefsrc_len)
+		ynl_attr_put(nlh, RTA_PREFSRC, req->prefsrc, req->_present.prefsrc_len);
+	if (req->_present.metrics)
+		rt_route_metrics_put(nlh, RTA_METRICS, &req->metrics);
+	if (req->_present.multipath_len)
+		ynl_attr_put(nlh, RTA_MULTIPATH, req->multipath, req->_present.multipath_len);
+	if (req->_present.flow)
+		ynl_attr_put_u32(nlh, RTA_FLOW, req->flow);
+	if (req->_present.cacheinfo_len)
+		ynl_attr_put(nlh, RTA_CACHEINFO, req->cacheinfo, req->_present.cacheinfo_len);
+	if (req->_present.table)
+		ynl_attr_put_u32(nlh, RTA_TABLE, req->table);
+	if (req->_present.mark)
+		ynl_attr_put_u32(nlh, RTA_MARK, req->mark);
+	if (req->_present.mfc_stats_len)
+		ynl_attr_put(nlh, RTA_MFC_STATS, req->mfc_stats, req->_present.mfc_stats_len);
+	if (req->_present.via_len)
+		ynl_attr_put(nlh, RTA_VIA, req->via, req->_present.via_len);
+	if (req->_present.newdst_len)
+		ynl_attr_put(nlh, RTA_NEWDST, req->newdst, req->_present.newdst_len);
+	if (req->_present.pref)
+		ynl_attr_put_u8(nlh, RTA_PREF, req->pref);
+	if (req->_present.encap_type)
+		ynl_attr_put_u16(nlh, RTA_ENCAP_TYPE, req->encap_type);
+	if (req->_present.encap_len)
+		ynl_attr_put(nlh, RTA_ENCAP, req->encap, req->_present.encap_len);
+	if (req->_present.expires)
+		ynl_attr_put_u32(nlh, RTA_EXPIRES, req->expires);
+	if (req->_present.pad_len)
+		ynl_attr_put(nlh, RTA_PAD, req->pad, req->_present.pad_len);
+	if (req->_present.uid)
+		ynl_attr_put_u32(nlh, RTA_UID, req->uid);
+	if (req->_present.ttl_propagate)
+		ynl_attr_put_u8(nlh, RTA_TTL_PROPAGATE, req->ttl_propagate);
+	if (req->_present.ip_proto)
+		ynl_attr_put_u8(nlh, RTA_IP_PROTO, req->ip_proto);
+	if (req->_present.sport)
+		ynl_attr_put_u16(nlh, RTA_SPORT, req->sport);
+	if (req->_present.dport)
+		ynl_attr_put_u16(nlh, RTA_DPORT, req->dport);
+	if (req->_present.nh_id)
+		ynl_attr_put_u32(nlh, RTA_NH_ID, req->nh_id);
+	if (req->_present.flowlabel)
+		ynl_attr_put_u32(nlh, RTA_FLOWLABEL, req->flowlabel);
+
+	err = ynl_exec(ys, nlh, &yrs);
+	if (err < 0)
+		return -1;
+
+	return 0;
+}
+
+const struct ynl_family ynl_rt_route_family =  {
+	.name		= "rt_route",
+	.is_classic	= true,
+	.classic_id	= 0,
+	.hdr_len	= sizeof(struct rtmsg),
+};
diff --git a/home/nipa/nipa_out/951794/ynl/new-code/rt-route-user.h b/home/nipa/nipa_out/951794/ynl/new-code/rt-route-user.h
new file mode 100644
index 000000000000..fd5d77d40441
--- /dev/null
+++ b/home/nipa/nipa_out/951794/ynl/new-code/rt-route-user.h
@@ -0,0 +1,1099 @@
+/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) */
+/* Do not edit directly, auto-generated from: */
+/*	Documentation/netlink/specs/rt-route.yaml */
+/* YNL-GEN user header */
+
+#ifndef _LINUX_RT_ROUTE_GEN_H
+#define _LINUX_RT_ROUTE_GEN_H
+
+#include <stdlib.h>
+#include <string.h>
+#include <linux/types.h>
+#include <linux/rtnetlink.h>
+
+struct ynl_sock;
+
+extern const struct ynl_family ynl_rt_route_family;
+
+/* Enums */
+const char *rt_route_op_str(int op);
+const char *rt_route_rtm_type_str(int value);
+
+/* Common nested types */
+struct rt_route_metrics {
+	struct {
+		__u32 lock:1;
+		__u32 mtu:1;
+		__u32 window:1;
+		__u32 rtt:1;
+		__u32 rttvar:1;
+		__u32 ssthresh:1;
+		__u32 cwnd:1;
+		__u32 advmss:1;
+		__u32 reordering:1;
+		__u32 hoplimit:1;
+		__u32 initcwnd:1;
+		__u32 features:1;
+		__u32 rto_min:1;
+		__u32 initrwnd:1;
+		__u32 quickack:1;
+		__u32 cc_algo_len;
+		__u32 fastopen_no_cookie:1;
+	} _present;
+
+	__u32 lock;
+	__u32 mtu;
+	__u32 window;
+	__u32 rtt;
+	__u32 rttvar;
+	__u32 ssthresh;
+	__u32 cwnd;
+	__u32 advmss;
+	__u32 reordering;
+	__u32 hoplimit;
+	__u32 initcwnd;
+	__u32 features;
+	__u32 rto_min;
+	__u32 initrwnd;
+	__u32 quickack;
+	char *cc_algo;
+	__u32 fastopen_no_cookie;
+};
+
+/* ============== RTM_GETROUTE ============== */
+/* RTM_GETROUTE - do */
+struct rt_route_getroute_req {
+	struct rtmsg _hdr;
+
+	struct {
+		__u32 src_len;
+		__u32 dst_len;
+		__u32 iif:1;
+		__u32 oif:1;
+		__u32 ip_proto:1;
+		__u32 sport:1;
+		__u32 dport:1;
+		__u32 mark:1;
+		__u32 uid:1;
+		__u32 flowlabel:1;
+	} _present;
+
+	void *src;
+	void *dst;
+	__u32 iif;
+	__u32 oif;
+	__u8 ip_proto;
+	__u16 sport;
+	__u16 dport;
+	__u32 mark;
+	__u32 uid;
+	__u32 flowlabel /* big-endian */;
+};
+
+static inline struct rt_route_getroute_req *rt_route_getroute_req_alloc(void)
+{
+	return calloc(1, sizeof(struct rt_route_getroute_req));
+}
+void rt_route_getroute_req_free(struct rt_route_getroute_req *req);
+
+static inline void
+rt_route_getroute_req_set_src(struct rt_route_getroute_req *req,
+			      const void *src, size_t len)
+{
+	free(req->src);
+	req->_present.src_len = len;
+	req->src = malloc(req->_present.src_len);
+	memcpy(req->src, src, req->_present.src_len);
+}
+static inline void
+rt_route_getroute_req_set_dst(struct rt_route_getroute_req *req,
+			      const void *dst, size_t len)
+{
+	free(req->dst);
+	req->_present.dst_len = len;
+	req->dst = malloc(req->_present.dst_len);
+	memcpy(req->dst, dst, req->_present.dst_len);
+}
+static inline void
+rt_route_getroute_req_set_iif(struct rt_route_getroute_req *req, __u32 iif)
+{
+	req->_present.iif = 1;
+	req->iif = iif;
+}
+static inline void
+rt_route_getroute_req_set_oif(struct rt_route_getroute_req *req, __u32 oif)
+{
+	req->_present.oif = 1;
+	req->oif = oif;
+}
+static inline void
+rt_route_getroute_req_set_ip_proto(struct rt_route_getroute_req *req,
+				   __u8 ip_proto)
+{
+	req->_present.ip_proto = 1;
+	req->ip_proto = ip_proto;
+}
+static inline void
+rt_route_getroute_req_set_sport(struct rt_route_getroute_req *req, __u16 sport)
+{
+	req->_present.sport = 1;
+	req->sport = sport;
+}
+static inline void
+rt_route_getroute_req_set_dport(struct rt_route_getroute_req *req, __u16 dport)
+{
+	req->_present.dport = 1;
+	req->dport = dport;
+}
+static inline void
+rt_route_getroute_req_set_mark(struct rt_route_getroute_req *req, __u32 mark)
+{
+	req->_present.mark = 1;
+	req->mark = mark;
+}
+static inline void
+rt_route_getroute_req_set_uid(struct rt_route_getroute_req *req, __u32 uid)
+{
+	req->_present.uid = 1;
+	req->uid = uid;
+}
+static inline void
+rt_route_getroute_req_set_flowlabel(struct rt_route_getroute_req *req,
+				    __u32 flowlabel /* big-endian */)
+{
+	req->_present.flowlabel = 1;
+	req->flowlabel = flowlabel;
+}
+
+struct rt_route_getroute_rsp {
+	struct rtmsg _hdr;
+
+	struct {
+		__u32 dst_len;
+		__u32 src_len;
+		__u32 iif:1;
+		__u32 oif:1;
+		__u32 gateway_len;
+		__u32 priority:1;
+		__u32 prefsrc_len;
+		__u32 metrics:1;
+		__u32 multipath_len;
+		__u32 flow:1;
+		__u32 cacheinfo_len;
+		__u32 table:1;
+		__u32 mark:1;
+		__u32 mfc_stats_len;
+		__u32 via_len;
+		__u32 newdst_len;
+		__u32 pref:1;
+		__u32 encap_type:1;
+		__u32 encap_len;
+		__u32 expires:1;
+		__u32 pad_len;
+		__u32 uid:1;
+		__u32 ttl_propagate:1;
+		__u32 ip_proto:1;
+		__u32 sport:1;
+		__u32 dport:1;
+		__u32 nh_id:1;
+		__u32 flowlabel:1;
+	} _present;
+
+	void *dst;
+	void *src;
+	__u32 iif;
+	__u32 oif;
+	void *gateway;
+	__u32 priority;
+	void *prefsrc;
+	struct rt_route_metrics metrics;
+	void *multipath;
+	__u32 flow;
+	void *cacheinfo;
+	__u32 table;
+	__u32 mark;
+	void *mfc_stats;
+	void *via;
+	void *newdst;
+	__u8 pref;
+	__u16 encap_type;
+	void *encap;
+	__u32 expires;
+	void *pad;
+	__u32 uid;
+	__u8 ttl_propagate;
+	__u8 ip_proto;
+	__u16 sport;
+	__u16 dport;
+	__u32 nh_id;
+	__u32 flowlabel /* big-endian */;
+};
+
+void rt_route_getroute_rsp_free(struct rt_route_getroute_rsp *rsp);
+
+/*
+ * Dump route information.
+ */
+struct rt_route_getroute_rsp *
+rt_route_getroute(struct ynl_sock *ys, struct rt_route_getroute_req *req);
+
+/* RTM_GETROUTE - dump */
+struct rt_route_getroute_req_dump {
+	struct rtmsg _hdr;
+};
+
+static inline struct rt_route_getroute_req_dump *
+rt_route_getroute_req_dump_alloc(void)
+{
+	return calloc(1, sizeof(struct rt_route_getroute_req_dump));
+}
+void rt_route_getroute_req_dump_free(struct rt_route_getroute_req_dump *req);
+
+struct rt_route_getroute_list {
+	struct rt_route_getroute_list *next;
+	struct rt_route_getroute_rsp obj __attribute__((aligned(8)));
+};
+
+void rt_route_getroute_list_free(struct rt_route_getroute_list *rsp);
+
+struct rt_route_getroute_list *
+rt_route_getroute_dump(struct ynl_sock *ys,
+		       struct rt_route_getroute_req_dump *req);
+
+/* ============== RTM_NEWROUTE ============== */
+/* RTM_NEWROUTE - do */
+struct rt_route_newroute_req {
+	struct rtmsg _hdr;
+
+	struct {
+		__u32 dst_len;
+		__u32 src_len;
+		__u32 iif:1;
+		__u32 oif:1;
+		__u32 gateway_len;
+		__u32 priority:1;
+		__u32 prefsrc_len;
+		__u32 metrics:1;
+		__u32 multipath_len;
+		__u32 flow:1;
+		__u32 cacheinfo_len;
+		__u32 table:1;
+		__u32 mark:1;
+		__u32 mfc_stats_len;
+		__u32 via_len;
+		__u32 newdst_len;
+		__u32 pref:1;
+		__u32 encap_type:1;
+		__u32 encap_len;
+		__u32 expires:1;
+		__u32 pad_len;
+		__u32 uid:1;
+		__u32 ttl_propagate:1;
+		__u32 ip_proto:1;
+		__u32 sport:1;
+		__u32 dport:1;
+		__u32 nh_id:1;
+		__u32 flowlabel:1;
+	} _present;
+
+	void *dst;
+	void *src;
+	__u32 iif;
+	__u32 oif;
+	void *gateway;
+	__u32 priority;
+	void *prefsrc;
+	struct rt_route_metrics metrics;
+	void *multipath;
+	__u32 flow;
+	void *cacheinfo;
+	__u32 table;
+	__u32 mark;
+	void *mfc_stats;
+	void *via;
+	void *newdst;
+	__u8 pref;
+	__u16 encap_type;
+	void *encap;
+	__u32 expires;
+	void *pad;
+	__u32 uid;
+	__u8 ttl_propagate;
+	__u8 ip_proto;
+	__u16 sport;
+	__u16 dport;
+	__u32 nh_id;
+	__u32 flowlabel /* big-endian */;
+};
+
+static inline struct rt_route_newroute_req *rt_route_newroute_req_alloc(void)
+{
+	return calloc(1, sizeof(struct rt_route_newroute_req));
+}
+void rt_route_newroute_req_free(struct rt_route_newroute_req *req);
+
+static inline void
+rt_route_newroute_req_set_dst(struct rt_route_newroute_req *req,
+			      const void *dst, size_t len)
+{
+	free(req->dst);
+	req->_present.dst_len = len;
+	req->dst = malloc(req->_present.dst_len);
+	memcpy(req->dst, dst, req->_present.dst_len);
+}
+static inline void
+rt_route_newroute_req_set_src(struct rt_route_newroute_req *req,
+			      const void *src, size_t len)
+{
+	free(req->src);
+	req->_present.src_len = len;
+	req->src = malloc(req->_present.src_len);
+	memcpy(req->src, src, req->_present.src_len);
+}
+static inline void
+rt_route_newroute_req_set_iif(struct rt_route_newroute_req *req, __u32 iif)
+{
+	req->_present.iif = 1;
+	req->iif = iif;
+}
+static inline void
+rt_route_newroute_req_set_oif(struct rt_route_newroute_req *req, __u32 oif)
+{
+	req->_present.oif = 1;
+	req->oif = oif;
+}
+static inline void
+rt_route_newroute_req_set_gateway(struct rt_route_newroute_req *req,
+				  const void *gateway, size_t len)
+{
+	free(req->gateway);
+	req->_present.gateway_len = len;
+	req->gateway = malloc(req->_present.gateway_len);
+	memcpy(req->gateway, gateway, req->_present.gateway_len);
+}
+static inline void
+rt_route_newroute_req_set_priority(struct rt_route_newroute_req *req,
+				   __u32 priority)
+{
+	req->_present.priority = 1;
+	req->priority = priority;
+}
+static inline void
+rt_route_newroute_req_set_prefsrc(struct rt_route_newroute_req *req,
+				  const void *prefsrc, size_t len)
+{
+	free(req->prefsrc);
+	req->_present.prefsrc_len = len;
+	req->prefsrc = malloc(req->_present.prefsrc_len);
+	memcpy(req->prefsrc, prefsrc, req->_present.prefsrc_len);
+}
+static inline void
+rt_route_newroute_req_set_metrics_lock(struct rt_route_newroute_req *req,
+				       __u32 lock)
+{
+	req->_present.metrics = 1;
+	req->metrics._present.lock = 1;
+	req->metrics.lock = lock;
+}
+static inline void
+rt_route_newroute_req_set_metrics_mtu(struct rt_route_newroute_req *req,
+				      __u32 mtu)
+{
+	req->_present.metrics = 1;
+	req->metrics._present.mtu = 1;
+	req->metrics.mtu = mtu;
+}
+static inline void
+rt_route_newroute_req_set_metrics_window(struct rt_route_newroute_req *req,
+					 __u32 window)
+{
+	req->_present.metrics = 1;
+	req->metrics._present.window = 1;
+	req->metrics.window = window;
+}
+static inline void
+rt_route_newroute_req_set_metrics_rtt(struct rt_route_newroute_req *req,
+				      __u32 rtt)
+{
+	req->_present.metrics = 1;
+	req->metrics._present.rtt = 1;
+	req->metrics.rtt = rtt;
+}
+static inline void
+rt_route_newroute_req_set_metrics_rttvar(struct rt_route_newroute_req *req,
+					 __u32 rttvar)
+{
+	req->_present.metrics = 1;
+	req->metrics._present.rttvar = 1;
+	req->metrics.rttvar = rttvar;
+}
+static inline void
+rt_route_newroute_req_set_metrics_ssthresh(struct rt_route_newroute_req *req,
+					   __u32 ssthresh)
+{
+	req->_present.metrics = 1;
+	req->metrics._present.ssthresh = 1;
+	req->metrics.ssthresh = ssthresh;
+}
+static inline void
+rt_route_newroute_req_set_metrics_cwnd(struct rt_route_newroute_req *req,
+				       __u32 cwnd)
+{
+	req->_present.metrics = 1;
+	req->metrics._present.cwnd = 1;
+	req->metrics.cwnd = cwnd;
+}
+static inline void
+rt_route_newroute_req_set_metrics_advmss(struct rt_route_newroute_req *req,
+					 __u32 advmss)
+{
+	req->_present.metrics = 1;
+	req->metrics._present.advmss = 1;
+	req->metrics.advmss = advmss;
+}
+static inline void
+rt_route_newroute_req_set_metrics_reordering(struct rt_route_newroute_req *req,
+					     __u32 reordering)
+{
+	req->_present.metrics = 1;
+	req->metrics._present.reordering = 1;
+	req->metrics.reordering = reordering;
+}
+static inline void
+rt_route_newroute_req_set_metrics_hoplimit(struct rt_route_newroute_req *req,
+					   __u32 hoplimit)
+{
+	req->_present.metrics = 1;
+	req->metrics._present.hoplimit = 1;
+	req->metrics.hoplimit = hoplimit;
+}
+static inline void
+rt_route_newroute_req_set_metrics_initcwnd(struct rt_route_newroute_req *req,
+					   __u32 initcwnd)
+{
+	req->_present.metrics = 1;
+	req->metrics._present.initcwnd = 1;
+	req->metrics.initcwnd = initcwnd;
+}
+static inline void
+rt_route_newroute_req_set_metrics_features(struct rt_route_newroute_req *req,
+					   __u32 features)
+{
+	req->_present.metrics = 1;
+	req->metrics._present.features = 1;
+	req->metrics.features = features;
+}
+static inline void
+rt_route_newroute_req_set_metrics_rto_min(struct rt_route_newroute_req *req,
+					  __u32 rto_min)
+{
+	req->_present.metrics = 1;
+	req->metrics._present.rto_min = 1;
+	req->metrics.rto_min = rto_min;
+}
+static inline void
+rt_route_newroute_req_set_metrics_initrwnd(struct rt_route_newroute_req *req,
+					   __u32 initrwnd)
+{
+	req->_present.metrics = 1;
+	req->metrics._present.initrwnd = 1;
+	req->metrics.initrwnd = initrwnd;
+}
+static inline void
+rt_route_newroute_req_set_metrics_quickack(struct rt_route_newroute_req *req,
+					   __u32 quickack)
+{
+	req->_present.metrics = 1;
+	req->metrics._present.quickack = 1;
+	req->metrics.quickack = quickack;
+}
+static inline void
+rt_route_newroute_req_set_metrics_cc_algo(struct rt_route_newroute_req *req,
+					  const char *cc_algo)
+{
+	req->_present.metrics = 1;
+	free(req->metrics.cc_algo);
+	req->metrics._present.cc_algo_len = strlen(cc_algo);
+	req->metrics.cc_algo = malloc(req->metrics._present.cc_algo_len + 1);
+	memcpy(req->metrics.cc_algo, cc_algo, req->metrics._present.cc_algo_len);
+	req->metrics.cc_algo[req->metrics._present.cc_algo_len] = 0;
+}
+static inline void
+rt_route_newroute_req_set_metrics_fastopen_no_cookie(struct rt_route_newroute_req *req,
+						     __u32 fastopen_no_cookie)
+{
+	req->_present.metrics = 1;
+	req->metrics._present.fastopen_no_cookie = 1;
+	req->metrics.fastopen_no_cookie = fastopen_no_cookie;
+}
+static inline void
+rt_route_newroute_req_set_multipath(struct rt_route_newroute_req *req,
+				    const void *multipath, size_t len)
+{
+	free(req->multipath);
+	req->_present.multipath_len = len;
+	req->multipath = malloc(req->_present.multipath_len);
+	memcpy(req->multipath, multipath, req->_present.multipath_len);
+}
+static inline void
+rt_route_newroute_req_set_flow(struct rt_route_newroute_req *req, __u32 flow)
+{
+	req->_present.flow = 1;
+	req->flow = flow;
+}
+static inline void
+rt_route_newroute_req_set_cacheinfo(struct rt_route_newroute_req *req,
+				    const void *cacheinfo, size_t len)
+{
+	free(req->cacheinfo);
+	req->_present.cacheinfo_len = len;
+	req->cacheinfo = malloc(req->_present.cacheinfo_len);
+	memcpy(req->cacheinfo, cacheinfo, req->_present.cacheinfo_len);
+}
+static inline void
+rt_route_newroute_req_set_table(struct rt_route_newroute_req *req, __u32 table)
+{
+	req->_present.table = 1;
+	req->table = table;
+}
+static inline void
+rt_route_newroute_req_set_mark(struct rt_route_newroute_req *req, __u32 mark)
+{
+	req->_present.mark = 1;
+	req->mark = mark;
+}
+static inline void
+rt_route_newroute_req_set_mfc_stats(struct rt_route_newroute_req *req,
+				    const void *mfc_stats, size_t len)
+{
+	free(req->mfc_stats);
+	req->_present.mfc_stats_len = len;
+	req->mfc_stats = malloc(req->_present.mfc_stats_len);
+	memcpy(req->mfc_stats, mfc_stats, req->_present.mfc_stats_len);
+}
+static inline void
+rt_route_newroute_req_set_via(struct rt_route_newroute_req *req,
+			      const void *via, size_t len)
+{
+	free(req->via);
+	req->_present.via_len = len;
+	req->via = malloc(req->_present.via_len);
+	memcpy(req->via, via, req->_present.via_len);
+}
+static inline void
+rt_route_newroute_req_set_newdst(struct rt_route_newroute_req *req,
+				 const void *newdst, size_t len)
+{
+	free(req->newdst);
+	req->_present.newdst_len = len;
+	req->newdst = malloc(req->_present.newdst_len);
+	memcpy(req->newdst, newdst, req->_present.newdst_len);
+}
+static inline void
+rt_route_newroute_req_set_pref(struct rt_route_newroute_req *req, __u8 pref)
+{
+	req->_present.pref = 1;
+	req->pref = pref;
+}
+static inline void
+rt_route_newroute_req_set_encap_type(struct rt_route_newroute_req *req,
+				     __u16 encap_type)
+{
+	req->_present.encap_type = 1;
+	req->encap_type = encap_type;
+}
+static inline void
+rt_route_newroute_req_set_encap(struct rt_route_newroute_req *req,
+				const void *encap, size_t len)
+{
+	free(req->encap);
+	req->_present.encap_len = len;
+	req->encap = malloc(req->_present.encap_len);
+	memcpy(req->encap, encap, req->_present.encap_len);
+}
+static inline void
+rt_route_newroute_req_set_expires(struct rt_route_newroute_req *req,
+				  __u32 expires)
+{
+	req->_present.expires = 1;
+	req->expires = expires;
+}
+static inline void
+rt_route_newroute_req_set_pad(struct rt_route_newroute_req *req,
+			      const void *pad, size_t len)
+{
+	free(req->pad);
+	req->_present.pad_len = len;
+	req->pad = malloc(req->_present.pad_len);
+	memcpy(req->pad, pad, req->_present.pad_len);
+}
+static inline void
+rt_route_newroute_req_set_uid(struct rt_route_newroute_req *req, __u32 uid)
+{
+	req->_present.uid = 1;
+	req->uid = uid;
+}
+static inline void
+rt_route_newroute_req_set_ttl_propagate(struct rt_route_newroute_req *req,
+					__u8 ttl_propagate)
+{
+	req->_present.ttl_propagate = 1;
+	req->ttl_propagate = ttl_propagate;
+}
+static inline void
+rt_route_newroute_req_set_ip_proto(struct rt_route_newroute_req *req,
+				   __u8 ip_proto)
+{
+	req->_present.ip_proto = 1;
+	req->ip_proto = ip_proto;
+}
+static inline void
+rt_route_newroute_req_set_sport(struct rt_route_newroute_req *req, __u16 sport)
+{
+	req->_present.sport = 1;
+	req->sport = sport;
+}
+static inline void
+rt_route_newroute_req_set_dport(struct rt_route_newroute_req *req, __u16 dport)
+{
+	req->_present.dport = 1;
+	req->dport = dport;
+}
+static inline void
+rt_route_newroute_req_set_nh_id(struct rt_route_newroute_req *req, __u32 nh_id)
+{
+	req->_present.nh_id = 1;
+	req->nh_id = nh_id;
+}
+static inline void
+rt_route_newroute_req_set_flowlabel(struct rt_route_newroute_req *req,
+				    __u32 flowlabel /* big-endian */)
+{
+	req->_present.flowlabel = 1;
+	req->flowlabel = flowlabel;
+}
+
+/*
+ * Create a new route
+ */
+int rt_route_newroute(struct ynl_sock *ys, struct rt_route_newroute_req *req);
+
+/* ============== RTM_DELROUTE ============== */
+/* RTM_DELROUTE - do */
+struct rt_route_delroute_req {
+	struct rtmsg _hdr;
+
+	struct {
+		__u32 dst_len;
+		__u32 src_len;
+		__u32 iif:1;
+		__u32 oif:1;
+		__u32 gateway_len;
+		__u32 priority:1;
+		__u32 prefsrc_len;
+		__u32 metrics:1;
+		__u32 multipath_len;
+		__u32 flow:1;
+		__u32 cacheinfo_len;
+		__u32 table:1;
+		__u32 mark:1;
+		__u32 mfc_stats_len;
+		__u32 via_len;
+		__u32 newdst_len;
+		__u32 pref:1;
+		__u32 encap_type:1;
+		__u32 encap_len;
+		__u32 expires:1;
+		__u32 pad_len;
+		__u32 uid:1;
+		__u32 ttl_propagate:1;
+		__u32 ip_proto:1;
+		__u32 sport:1;
+		__u32 dport:1;
+		__u32 nh_id:1;
+		__u32 flowlabel:1;
+	} _present;
+
+	void *dst;
+	void *src;
+	__u32 iif;
+	__u32 oif;
+	void *gateway;
+	__u32 priority;
+	void *prefsrc;
+	struct rt_route_metrics metrics;
+	void *multipath;
+	__u32 flow;
+	void *cacheinfo;
+	__u32 table;
+	__u32 mark;
+	void *mfc_stats;
+	void *via;
+	void *newdst;
+	__u8 pref;
+	__u16 encap_type;
+	void *encap;
+	__u32 expires;
+	void *pad;
+	__u32 uid;
+	__u8 ttl_propagate;
+	__u8 ip_proto;
+	__u16 sport;
+	__u16 dport;
+	__u32 nh_id;
+	__u32 flowlabel /* big-endian */;
+};
+
+static inline struct rt_route_delroute_req *rt_route_delroute_req_alloc(void)
+{
+	return calloc(1, sizeof(struct rt_route_delroute_req));
+}
+void rt_route_delroute_req_free(struct rt_route_delroute_req *req);
+
+static inline void
+rt_route_delroute_req_set_dst(struct rt_route_delroute_req *req,
+			      const void *dst, size_t len)
+{
+	free(req->dst);
+	req->_present.dst_len = len;
+	req->dst = malloc(req->_present.dst_len);
+	memcpy(req->dst, dst, req->_present.dst_len);
+}
+static inline void
+rt_route_delroute_req_set_src(struct rt_route_delroute_req *req,
+			      const void *src, size_t len)
+{
+	free(req->src);
+	req->_present.src_len = len;
+	req->src = malloc(req->_present.src_len);
+	memcpy(req->src, src, req->_present.src_len);
+}
+static inline void
+rt_route_delroute_req_set_iif(struct rt_route_delroute_req *req, __u32 iif)
+{
+	req->_present.iif = 1;
+	req->iif = iif;
+}
+static inline void
+rt_route_delroute_req_set_oif(struct rt_route_delroute_req *req, __u32 oif)
+{
+	req->_present.oif = 1;
+	req->oif = oif;
+}
+static inline void
+rt_route_delroute_req_set_gateway(struct rt_route_delroute_req *req,
+				  const void *gateway, size_t len)
+{
+	free(req->gateway);
+	req->_present.gateway_len = len;
+	req->gateway = malloc(req->_present.gateway_len);
+	memcpy(req->gateway, gateway, req->_present.gateway_len);
+}
+static inline void
+rt_route_delroute_req_set_priority(struct rt_route_delroute_req *req,
+				   __u32 priority)
+{
+	req->_present.priority = 1;
+	req->priority = priority;
+}
+static inline void
+rt_route_delroute_req_set_prefsrc(struct rt_route_delroute_req *req,
+				  const void *prefsrc, size_t len)
+{
+	free(req->prefsrc);
+	req->_present.prefsrc_len = len;
+	req->prefsrc = malloc(req->_present.prefsrc_len);
+	memcpy(req->prefsrc, prefsrc, req->_present.prefsrc_len);
+}
+static inline void
+rt_route_delroute_req_set_metrics_lock(struct rt_route_delroute_req *req,
+				       __u32 lock)
+{
+	req->_present.metrics = 1;
+	req->metrics._present.lock = 1;
+	req->metrics.lock = lock;
+}
+static inline void
+rt_route_delroute_req_set_metrics_mtu(struct rt_route_delroute_req *req,
+				      __u32 mtu)
+{
+	req->_present.metrics = 1;
+	req->metrics._present.mtu = 1;
+	req->metrics.mtu = mtu;
+}
+static inline void
+rt_route_delroute_req_set_metrics_window(struct rt_route_delroute_req *req,
+					 __u32 window)
+{
+	req->_present.metrics = 1;
+	req->metrics._present.window = 1;
+	req->metrics.window = window;
+}
+static inline void
+rt_route_delroute_req_set_metrics_rtt(struct rt_route_delroute_req *req,
+				      __u32 rtt)
+{
+	req->_present.metrics = 1;
+	req->metrics._present.rtt = 1;
+	req->metrics.rtt = rtt;
+}
+static inline void
+rt_route_delroute_req_set_metrics_rttvar(struct rt_route_delroute_req *req,
+					 __u32 rttvar)
+{
+	req->_present.metrics = 1;
+	req->metrics._present.rttvar = 1;
+	req->metrics.rttvar = rttvar;
+}
+static inline void
+rt_route_delroute_req_set_metrics_ssthresh(struct rt_route_delroute_req *req,
+					   __u32 ssthresh)
+{
+	req->_present.metrics = 1;
+	req->metrics._present.ssthresh = 1;
+	req->metrics.ssthresh = ssthresh;
+}
+static inline void
+rt_route_delroute_req_set_metrics_cwnd(struct rt_route_delroute_req *req,
+				       __u32 cwnd)
+{
+	req->_present.metrics = 1;
+	req->metrics._present.cwnd = 1;
+	req->metrics.cwnd = cwnd;
+}
+static inline void
+rt_route_delroute_req_set_metrics_advmss(struct rt_route_delroute_req *req,
+					 __u32 advmss)
+{
+	req->_present.metrics = 1;
+	req->metrics._present.advmss = 1;
+	req->metrics.advmss = advmss;
+}
+static inline void
+rt_route_delroute_req_set_metrics_reordering(struct rt_route_delroute_req *req,
+					     __u32 reordering)
+{
+	req->_present.metrics = 1;
+	req->metrics._present.reordering = 1;
+	req->metrics.reordering = reordering;
+}
+static inline void
+rt_route_delroute_req_set_metrics_hoplimit(struct rt_route_delroute_req *req,
+					   __u32 hoplimit)
+{
+	req->_present.metrics = 1;
+	req->metrics._present.hoplimit = 1;
+	req->metrics.hoplimit = hoplimit;
+}
+static inline void
+rt_route_delroute_req_set_metrics_initcwnd(struct rt_route_delroute_req *req,
+					   __u32 initcwnd)
+{
+	req->_present.metrics = 1;
+	req->metrics._present.initcwnd = 1;
+	req->metrics.initcwnd = initcwnd;
+}
+static inline void
+rt_route_delroute_req_set_metrics_features(struct rt_route_delroute_req *req,
+					   __u32 features)
+{
+	req->_present.metrics = 1;
+	req->metrics._present.features = 1;
+	req->metrics.features = features;
+}
+static inline void
+rt_route_delroute_req_set_metrics_rto_min(struct rt_route_delroute_req *req,
+					  __u32 rto_min)
+{
+	req->_present.metrics = 1;
+	req->metrics._present.rto_min = 1;
+	req->metrics.rto_min = rto_min;
+}
+static inline void
+rt_route_delroute_req_set_metrics_initrwnd(struct rt_route_delroute_req *req,
+					   __u32 initrwnd)
+{
+	req->_present.metrics = 1;
+	req->metrics._present.initrwnd = 1;
+	req->metrics.initrwnd = initrwnd;
+}
+static inline void
+rt_route_delroute_req_set_metrics_quickack(struct rt_route_delroute_req *req,
+					   __u32 quickack)
+{
+	req->_present.metrics = 1;
+	req->metrics._present.quickack = 1;
+	req->metrics.quickack = quickack;
+}
+static inline void
+rt_route_delroute_req_set_metrics_cc_algo(struct rt_route_delroute_req *req,
+					  const char *cc_algo)
+{
+	req->_present.metrics = 1;
+	free(req->metrics.cc_algo);
+	req->metrics._present.cc_algo_len = strlen(cc_algo);
+	req->metrics.cc_algo = malloc(req->metrics._present.cc_algo_len + 1);
+	memcpy(req->metrics.cc_algo, cc_algo, req->metrics._present.cc_algo_len);
+	req->metrics.cc_algo[req->metrics._present.cc_algo_len] = 0;
+}
+static inline void
+rt_route_delroute_req_set_metrics_fastopen_no_cookie(struct rt_route_delroute_req *req,
+						     __u32 fastopen_no_cookie)
+{
+	req->_present.metrics = 1;
+	req->metrics._present.fastopen_no_cookie = 1;
+	req->metrics.fastopen_no_cookie = fastopen_no_cookie;
+}
+static inline void
+rt_route_delroute_req_set_multipath(struct rt_route_delroute_req *req,
+				    const void *multipath, size_t len)
+{
+	free(req->multipath);
+	req->_present.multipath_len = len;
+	req->multipath = malloc(req->_present.multipath_len);
+	memcpy(req->multipath, multipath, req->_present.multipath_len);
+}
+static inline void
+rt_route_delroute_req_set_flow(struct rt_route_delroute_req *req, __u32 flow)
+{
+	req->_present.flow = 1;
+	req->flow = flow;
+}
+static inline void
+rt_route_delroute_req_set_cacheinfo(struct rt_route_delroute_req *req,
+				    const void *cacheinfo, size_t len)
+{
+	free(req->cacheinfo);
+	req->_present.cacheinfo_len = len;
+	req->cacheinfo = malloc(req->_present.cacheinfo_len);
+	memcpy(req->cacheinfo, cacheinfo, req->_present.cacheinfo_len);
+}
+static inline void
+rt_route_delroute_req_set_table(struct rt_route_delroute_req *req, __u32 table)
+{
+	req->_present.table = 1;
+	req->table = table;
+}
+static inline void
+rt_route_delroute_req_set_mark(struct rt_route_delroute_req *req, __u32 mark)
+{
+	req->_present.mark = 1;
+	req->mark = mark;
+}
+static inline void
+rt_route_delroute_req_set_mfc_stats(struct rt_route_delroute_req *req,
+				    const void *mfc_stats, size_t len)
+{
+	free(req->mfc_stats);
+	req->_present.mfc_stats_len = len;
+	req->mfc_stats = malloc(req->_present.mfc_stats_len);
+	memcpy(req->mfc_stats, mfc_stats, req->_present.mfc_stats_len);
+}
+static inline void
+rt_route_delroute_req_set_via(struct rt_route_delroute_req *req,
+			      const void *via, size_t len)
+{
+	free(req->via);
+	req->_present.via_len = len;
+	req->via = malloc(req->_present.via_len);
+	memcpy(req->via, via, req->_present.via_len);
+}
+static inline void
+rt_route_delroute_req_set_newdst(struct rt_route_delroute_req *req,
+				 const void *newdst, size_t len)
+{
+	free(req->newdst);
+	req->_present.newdst_len = len;
+	req->newdst = malloc(req->_present.newdst_len);
+	memcpy(req->newdst, newdst, req->_present.newdst_len);
+}
+static inline void
+rt_route_delroute_req_set_pref(struct rt_route_delroute_req *req, __u8 pref)
+{
+	req->_present.pref = 1;
+	req->pref = pref;
+}
+static inline void
+rt_route_delroute_req_set_encap_type(struct rt_route_delroute_req *req,
+				     __u16 encap_type)
+{
+	req->_present.encap_type = 1;
+	req->encap_type = encap_type;
+}
+static inline void
+rt_route_delroute_req_set_encap(struct rt_route_delroute_req *req,
+				const void *encap, size_t len)
+{
+	free(req->encap);
+	req->_present.encap_len = len;
+	req->encap = malloc(req->_present.encap_len);
+	memcpy(req->encap, encap, req->_present.encap_len);
+}
+static inline void
+rt_route_delroute_req_set_expires(struct rt_route_delroute_req *req,
+				  __u32 expires)
+{
+	req->_present.expires = 1;
+	req->expires = expires;
+}
+static inline void
+rt_route_delroute_req_set_pad(struct rt_route_delroute_req *req,
+			      const void *pad, size_t len)
+{
+	free(req->pad);
+	req->_present.pad_len = len;
+	req->pad = malloc(req->_present.pad_len);
+	memcpy(req->pad, pad, req->_present.pad_len);
+}
+static inline void
+rt_route_delroute_req_set_uid(struct rt_route_delroute_req *req, __u32 uid)
+{
+	req->_present.uid = 1;
+	req->uid = uid;
+}
+static inline void
+rt_route_delroute_req_set_ttl_propagate(struct rt_route_delroute_req *req,
+					__u8 ttl_propagate)
+{
+	req->_present.ttl_propagate = 1;
+	req->ttl_propagate = ttl_propagate;
+}
+static inline void
+rt_route_delroute_req_set_ip_proto(struct rt_route_delroute_req *req,
+				   __u8 ip_proto)
+{
+	req->_present.ip_proto = 1;
+	req->ip_proto = ip_proto;
+}
+static inline void
+rt_route_delroute_req_set_sport(struct rt_route_delroute_req *req, __u16 sport)
+{
+	req->_present.sport = 1;
+	req->sport = sport;
+}
+static inline void
+rt_route_delroute_req_set_dport(struct rt_route_delroute_req *req, __u16 dport)
+{
+	req->_present.dport = 1;
+	req->dport = dport;
+}
+static inline void
+rt_route_delroute_req_set_nh_id(struct rt_route_delroute_req *req, __u32 nh_id)
+{
+	req->_present.nh_id = 1;
+	req->nh_id = nh_id;
+}
+static inline void
+rt_route_delroute_req_set_flowlabel(struct rt_route_delroute_req *req,
+				    __u32 flowlabel /* big-endian */)
+{
+	req->_present.flowlabel = 1;
+	req->flowlabel = flowlabel;
+}
+
+/*
+ * Delete an existing route
+ */
+int rt_route_delroute(struct ynl_sock *ys, struct rt_route_delroute_req *req);
+
+#endif /* _LINUX_RT_ROUTE_GEN_H */