diff --git a/openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac.c b/openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac.c
index 669eb33ea335f03e72f4f7cae18d04b4765f0c8d..4800fccea9de936d91cf1292283fadf1ceb65378 100644
--- a/openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac.c
+++ b/openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac.c
@@ -1468,10 +1468,12 @@ void flexran_agent_fill_mac_ue_config(mid_t mod_id, mid_t ue_id,
   ue_conf->rnti = flexran_get_mac_ue_crnti(mod_id, ue_id);
   ue_conf->has_rnti = 1;
 
-  ue_conf->dl_slice_id = flexran_get_ue_dl_slice_id(mod_id, ue_id);
-  ue_conf->has_dl_slice_id = 1;
-  ue_conf->ul_slice_id = flexran_get_ue_ul_slice_id(mod_id, ue_id);
-  ue_conf->has_ul_slice_id = 1;
+  int dl_id = flexran_get_ue_dl_slice_id(mod_id, ue_id);
+  ue_conf->dl_slice_id = dl_id;
+  ue_conf->has_dl_slice_id = dl_id >= 0;
+  int ul_id = flexran_get_ue_ul_slice_id(mod_id, ue_id);
+  ue_conf->ul_slice_id = ul_id;
+  ue_conf->has_ul_slice_id = ul_id >= 0;
 
   ue_conf->ue_aggregated_max_bitrate_ul = flexran_get_ue_aggregated_max_bitrate_ul(mod_id, ue_id);
   ue_conf->has_ue_aggregated_max_bitrate_ul = 1;
@@ -1576,149 +1578,24 @@ void flexran_create_config_structures(mid_t mod_id)
   sc_update[mod_id] = flexran_agent_create_slice_config(n_dl, m_ul);
   if (!slice_config[mod_id] || !sc_update[mod_id]) return;
 
-  flexran_agent_read_slice_config(mod_id, slice_config[mod_id]);
-  flexran_agent_read_slice_config(mod_id, sc_update[mod_id]);
+  //flexran_agent_read_slice_config(mod_id, slice_config[mod_id]);
+  //flexran_agent_read_slice_config(mod_id, sc_update[mod_id]);
   for (i = 0; i < n_dl; i++) {
-    flexran_agent_read_slice_dl_config(mod_id, i, slice_config[mod_id]->dl[i]);
-    flexran_agent_read_slice_dl_config(mod_id, i, sc_update[mod_id]->dl[i]);
+    //flexran_agent_read_slice_dl_config(mod_id, i, slice_config[mod_id]->dl[i]);
+    //flexran_agent_read_slice_dl_config(mod_id, i, sc_update[mod_id]->dl[i]);
   }
   for (i = 0; i < m_ul; i++) {
-    flexran_agent_read_slice_ul_config(mod_id, i, slice_config[mod_id]->ul[i]);
-    flexran_agent_read_slice_ul_config(mod_id, i, sc_update[mod_id]->ul[i]);
+    //flexran_agent_read_slice_ul_config(mod_id, i, slice_config[mod_id]->ul[i]);
+    //flexran_agent_read_slice_ul_config(mod_id, i, sc_update[mod_id]->ul[i]);
   }
 }
 
 void flexran_check_and_remove_slices(mid_t mod_id)
 {
-  Protocol__FlexDlSlice **dl = sc_update[mod_id]->dl;
-  Protocol__FlexDlSlice **dlreal = slice_config[mod_id]->dl;
-  int i = 0;
-  while (i < sc_update[mod_id]->n_dl) {
-    /* remove slices whose percentage is zero */
-    if (dl[i]->percentage > 0) {
-      ++i;
-      continue;
-    }
-    if (flexran_remove_dl_slice(mod_id, i) < 1) {
-      LOG_W(FLEXRAN_AGENT, "[%d] can not remove slice index %d ID %d\n",
-            mod_id, i, dl[i]->id);
-      ++i;
-      continue;
-    }
-    LOG_I(FLEXRAN_AGENT, "[%d] removed slice index %d ID %d\n",
-          mod_id, i, dl[i]->id);
-    if (dl[i]->n_sorting > 0) free(dl[i]->sorting);
-    free(dl[i]->scheduler_name);
-    if (dlreal[i]->n_sorting > 0) {
-      dlreal[i]->n_sorting = 0;
-      free(dlreal[i]->sorting);
-    }
-    free(dlreal[i]->scheduler_name);
-    --sc_update[mod_id]->n_dl;
-    --slice_config[mod_id]->n_dl;
-    const size_t last = sc_update[mod_id]->n_dl;
-    /* we need to memcpy the higher slice to the position we just deleted */
-    memcpy(dl[i], dl[last], sizeof(*dl[last]));
-    memset(dl[last], 0, sizeof(*dl[last]));
-    memcpy(dlreal[i], dlreal[last], sizeof(*dlreal[last]));
-    memset(dlreal[last], 0, sizeof(*dlreal[last]));
-    /* dont increase i but recheck the slice which has been copied to here */
-  }
-  Protocol__FlexUlSlice **ul = sc_update[mod_id]->ul;
-  Protocol__FlexUlSlice **ulreal = slice_config[mod_id]->ul;
-  i = 0;
-  while (i < sc_update[mod_id]->n_ul) {
-    if (ul[i]->percentage > 0) {
-      ++i;
-      continue;
-    }
-    if (flexran_remove_ul_slice(mod_id, i) < 1) {
-      LOG_W(FLEXRAN_AGENT, "[%d] can not remove slice index %d ID %d\n",
-            mod_id, i, ul[i]->id);
-      ++i;
-      continue;
-    }
-    LOG_I(FLEXRAN_AGENT, "[%d] removed slice index %d ID %d\n",
-          mod_id, i, ul[i]->id);
-    free(ul[i]->scheduler_name);
-    free(ulreal[i]->scheduler_name);
-    --sc_update[mod_id]->n_ul;
-    --slice_config[mod_id]->n_ul;
-    const size_t last = sc_update[mod_id]->n_ul;
-    /* see DL remarks */
-    memcpy(ul[i], ul[last], sizeof(*ul[last]));
-    memset(ul[last], 0, sizeof(*ul[last]));
-    memcpy(ulreal[i], ulreal[last], sizeof(*ulreal[last]));
-    memset(ulreal[last], 0, sizeof(*ulreal[last]));
-    /* dont increase i but recheck the slice which has been copied to here */
-  }
 }
 
 void flexran_agent_slice_update(mid_t mod_id)
 {
-  int i;
-  int changes = 0;
-
-  if (perform_slice_config_update_count <= 0) return;
-  perform_slice_config_update_count--;
-
-  pthread_mutex_lock(&sc_update_mtx);
-
-  if (!slice_config[mod_id]) {
-    /* if the configuration does not exist for agent, create from eNB structure
-     * and exit */
-    flexran_create_config_structures(mod_id);
-    pthread_mutex_unlock(&sc_update_mtx);
-    return;
-  }
-
-  /********* read existing config *********/
-  /* simply update slice_config all the time and write new config
-   * (apply_new_slice_dl_config() only updates if changes are necessary) */
-  slice_config[mod_id]->n_dl = flexran_get_num_dl_slices(mod_id);
-  slice_config[mod_id]->n_ul = flexran_get_num_ul_slices(mod_id);
-  for (i = 0; i < slice_config[mod_id]->n_dl; i++) {
-    flexran_agent_read_slice_dl_config(mod_id, i, slice_config[mod_id]->dl[i]);
-  }
-  for (i = 0; i < slice_config[mod_id]->n_ul; i++) {
-    flexran_agent_read_slice_ul_config(mod_id, i, slice_config[mod_id]->ul[i]);
-  }
-
-  /********* write new config *********/
-  /* check for removal (sc_update[X]->dl[Y].percentage == 0)
-   * and update sc_update & slice_config accordingly */
-  flexran_check_and_remove_slices(mod_id);
-
-  /* create new DL and UL slices if necessary */
-  for (i = slice_config[mod_id]->n_dl; i < sc_update[mod_id]->n_dl; i++) {
-    flexran_create_dl_slice(mod_id, sc_update[mod_id]->dl[i]->id);
-  }
-  for (i = slice_config[mod_id]->n_ul; i < sc_update[mod_id]->n_ul; i++) {
-    flexran_create_ul_slice(mod_id, sc_update[mod_id]->ul[i]->id);
-  }
-  slice_config[mod_id]->n_dl = flexran_get_num_dl_slices(mod_id);
-  slice_config[mod_id]->n_ul = flexran_get_num_ul_slices(mod_id);
-  changes += apply_new_slice_config(mod_id, slice_config[mod_id], sc_update[mod_id]);
-  for (i = 0; i < slice_config[mod_id]->n_dl; i++) {
-    changes += apply_new_slice_dl_config(mod_id,
-                                         slice_config[mod_id]->dl[i],
-                                         sc_update[mod_id]->dl[i]);
-    flexran_agent_read_slice_dl_config(mod_id, i, slice_config[mod_id]->dl[i]);
-  }
-  for (i = 0; i < slice_config[mod_id]->n_ul; i++) {
-    changes += apply_new_slice_ul_config(mod_id,
-                                         slice_config[mod_id]->ul[i],
-                                         sc_update[mod_id]->ul[i]);
-    flexran_agent_read_slice_ul_config(mod_id, i, slice_config[mod_id]->ul[i]);
-  }
-  flexran_agent_read_slice_config(mod_id, slice_config[mod_id]);
-  if (n_ue_slice_assoc_updates > 0) {
-    changes += apply_ue_slice_assoc_update(mod_id);
-  }
-  if (changes > 0)
-    LOG_I(FLEXRAN_AGENT, "[%d] slice configuration: applied %d changes\n", mod_id, changes);
-
-  pthread_mutex_unlock(&sc_update_mtx);
 }
 
 Protocol__FlexSliceConfig *flexran_agent_get_slice_config(mid_t mod_id)
@@ -1727,69 +1604,10 @@ Protocol__FlexSliceConfig *flexran_agent_get_slice_config(mid_t mod_id)
   Protocol__FlexSliceConfig *config = NULL;
 
   pthread_mutex_lock(&sc_update_mtx);
-  config = flexran_agent_create_slice_config(slice_config[mod_id]->n_dl,
-                                             slice_config[mod_id]->n_ul);
   if (!config) {
     pthread_mutex_unlock(&sc_update_mtx);
     return NULL;
   }
-  config->has_intraslice_share_active = 1;
-  config->intraslice_share_active = slice_config[mod_id]->intraslice_share_active;
-  config->has_interslice_share_active = 1;
-  config->interslice_share_active = slice_config[mod_id]->interslice_share_active;
-  for (int i = 0; i < slice_config[mod_id]->n_dl; ++i) {
-    if (!config->dl[i]) continue;
-    config->dl[i]->has_id         = 1;
-    config->dl[i]->id             = slice_config[mod_id]->dl[i]->id;
-    config->dl[i]->has_label      = 1;
-    config->dl[i]->label          = slice_config[mod_id]->dl[i]->label;
-    config->dl[i]->has_percentage = 1;
-    config->dl[i]->percentage     = slice_config[mod_id]->dl[i]->percentage;
-    config->dl[i]->has_isolation  = 1;
-    config->dl[i]->isolation      = slice_config[mod_id]->dl[i]->isolation;
-    config->dl[i]->has_priority   = 1;
-    config->dl[i]->priority       = slice_config[mod_id]->dl[i]->priority;
-    config->dl[i]->has_position_low  = 1;
-    config->dl[i]->position_low   = slice_config[mod_id]->dl[i]->position_low;
-    config->dl[i]->has_position_high = 1;
-    config->dl[i]->position_high  = slice_config[mod_id]->dl[i]->position_high;
-    config->dl[i]->has_maxmcs     = 1;
-    config->dl[i]->maxmcs         = slice_config[mod_id]->dl[i]->maxmcs;
-    config->dl[i]->n_sorting      = slice_config[mod_id]->dl[i]->n_sorting;
-    config->dl[i]->sorting        = calloc(config->dl[i]->n_sorting, sizeof(Protocol__FlexDlSorting));
-    if (!config->dl[i]->sorting) config->dl[i]->n_sorting = 0;
-    for (int j = 0; j < config->dl[i]->n_sorting; ++j)
-      config->dl[i]->sorting[j]   = slice_config[mod_id]->dl[i]->sorting[j];
-    config->dl[i]->has_accounting = 1;
-    config->dl[i]->accounting     = slice_config[mod_id]->dl[i]->accounting;
-    config->dl[i]->scheduler_name = strdup(slice_config[mod_id]->dl[i]->scheduler_name);
-  }
-  for (int i = 0; i < slice_config[mod_id]->n_ul; ++i) {
-    if (!config->ul[i]) continue;
-    config->ul[i]->has_id         = 1;
-    config->ul[i]->id             = slice_config[mod_id]->ul[i]->id;
-    config->ul[i]->has_label      = 1;
-    config->ul[i]->label          = slice_config[mod_id]->ul[i]->label;
-    config->ul[i]->has_percentage = 1;
-    config->ul[i]->percentage     = slice_config[mod_id]->ul[i]->percentage;
-    config->ul[i]->has_isolation  = 1;
-    config->ul[i]->isolation      = slice_config[mod_id]->ul[i]->isolation;
-    config->ul[i]->has_priority   = 1;
-    config->ul[i]->priority       = slice_config[mod_id]->ul[i]->priority;
-    config->ul[i]->has_first_rb   = 1;
-    config->ul[i]->first_rb       = slice_config[mod_id]->ul[i]->first_rb;
-    config->ul[i]->has_maxmcs     = 1;
-    config->ul[i]->maxmcs         = slice_config[mod_id]->ul[i]->maxmcs;
-    config->ul[i]->n_sorting      = slice_config[mod_id]->ul[i]->n_sorting;
-    config->ul[i]->sorting        = calloc(config->ul[i]->n_sorting, sizeof(Protocol__FlexUlSorting));
-    if (!config->ul[i]->sorting) config->ul[i]->n_sorting = 0;
-    for (int j = 0; j < config->ul[i]->n_sorting; ++j)
-      config->ul[i]->sorting[j]   = slice_config[mod_id]->ul[i]->sorting[j];
-    config->ul[i]->has_accounting = 1;
-    config->ul[i]->accounting     = slice_config[mod_id]->ul[i]->accounting;
-    config->ul[i]->scheduler_name = strdup(slice_config[mod_id]->ul[i]->scheduler_name);
-  }
-
   pthread_mutex_unlock(&sc_update_mtx);
   return config;
 }
diff --git a/openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac_internal.c b/openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac_internal.c
index 84a28683b79c439154be562590963cccb0fd2ce4..4c80c561ee5ea4ffed0b9223920e1ed49fbac6a4 100644
--- a/openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac_internal.c
+++ b/openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac_internal.c
@@ -1027,666 +1027,18 @@ int load_dl_scheduler_function(mid_t mod_id, const char *function_name) {
 
 Protocol__FlexSliceConfig *flexran_agent_create_slice_config(int n_dl, int m_ul)
 {
-  int i;
   Protocol__FlexSliceConfig *fsc = malloc(sizeof(Protocol__FlexSliceConfig));
   if (!fsc) return NULL;
   protocol__flex_slice_config__init(fsc);
 
-  /* say there are n_dl slices but reserve memory for up to 10 so
-   * we don't need to reserve again later */
-  fsc->n_dl = n_dl;
-  fsc->dl = calloc(10, sizeof(Protocol__FlexDlSlice *));
-  if (!fsc->dl) fsc->n_dl = 0;
-  for (i = 0; i < 10; i++) {
-    fsc->dl[i] = malloc(sizeof(Protocol__FlexDlSlice));
-    if (!fsc->dl[i]) continue;
-    protocol__flex_dl_slice__init(fsc->dl[i]);
-  }
-
-  /* as above */
-  fsc->n_ul = m_ul;
-  fsc->ul = calloc(10, sizeof(Protocol__FlexUlSlice *));
-  if (!fsc->ul) fsc->n_ul = 0;
-  for (i = 0; i < 10; i++) {
-    fsc->ul[i] = malloc(sizeof(Protocol__FlexUlSlice));
-    if (!fsc->ul[i]) continue;
-    protocol__flex_ul_slice__init(fsc->ul[i]);
-  }
+  /* TODO */
   return fsc;
 }
 
-void flexran_agent_read_slice_config(mid_t mod_id, Protocol__FlexSliceConfig *s)
-{
-  s->intraslice_share_active = flexran_get_intraslice_sharing_active(mod_id);
-  s->has_intraslice_share_active = 1;
-  s->interslice_share_active = flexran_get_interslice_sharing_active(mod_id);
-  s->has_interslice_share_active = 1;
-}
-
-void flexran_agent_read_slice_dl_config(mid_t mod_id, int slice_idx, Protocol__FlexDlSlice *dl_slice)
-{
-  dl_slice->id = flexran_get_dl_slice_id(mod_id, slice_idx);
-  dl_slice->has_id = 1;
-  /* read label from corresponding sc_update entry or give default */
-  dl_slice->label = PROTOCOL__FLEX_SLICE_LABEL__xMBB;
-  dl_slice->has_label = 1;
-  for (int i = 0; i < sc_update[mod_id]->n_dl; i++) {
-    if (sc_update[mod_id]->dl[i]->id == dl_slice->id
-        && sc_update[mod_id]->dl[i]->has_label) {
-      dl_slice->label = sc_update[mod_id]->dl[i]->label;
-      break;
-    }
-  }
-  dl_slice->percentage = flexran_get_dl_slice_percentage(mod_id, slice_idx);
-  dl_slice->has_percentage = 1;
-  dl_slice->isolation = flexran_get_dl_slice_isolation(mod_id, slice_idx);
-  dl_slice->has_isolation = 1;
-  dl_slice->priority = flexran_get_dl_slice_priority(mod_id, slice_idx);
-  dl_slice->has_priority = 1;
-  dl_slice->position_low = flexran_get_dl_slice_position_low(mod_id, slice_idx);
-  dl_slice->has_position_low = 1;
-  dl_slice->position_high = flexran_get_dl_slice_position_high(mod_id, slice_idx);
-  dl_slice->has_position_high = 1;
-  dl_slice->maxmcs = flexran_get_dl_slice_maxmcs(mod_id, slice_idx);
-  dl_slice->has_maxmcs = 1;
-  dl_slice->n_sorting = flexran_get_dl_slice_sorting(mod_id, slice_idx, &dl_slice->sorting);
-  if (dl_slice->n_sorting < 1) dl_slice->sorting = NULL;
-  dl_slice->accounting = flexran_get_dl_slice_accounting_policy(mod_id, slice_idx);
-  dl_slice->has_accounting = 1;
-  const char *s_name = flexran_get_dl_slice_scheduler(mod_id, slice_idx);
-  if (!dl_slice->scheduler_name
-      || strcmp(dl_slice->scheduler_name, s_name) != 0) {
-    dl_slice->scheduler_name = realloc(dl_slice->scheduler_name, strlen(s_name) + 1);
-    strcpy(dl_slice->scheduler_name, s_name);
-  }
-}
-
-void flexran_agent_read_slice_ul_config(mid_t mod_id, int slice_idx, Protocol__FlexUlSlice *ul_slice)
-{
-  ul_slice->id = flexran_get_ul_slice_id(mod_id, slice_idx);
-  ul_slice->has_id = 1;
-  /* read label from corresponding sc_update entry or give default */
-  ul_slice->label = PROTOCOL__FLEX_SLICE_LABEL__xMBB;
-  ul_slice->has_label = 1;
-  for (int i = 0; i < sc_update[mod_id]->n_ul; i++) {
-    if (sc_update[mod_id]->ul[i]->id == ul_slice->id
-        && sc_update[mod_id]->ul[i]->has_label) {
-      ul_slice->label = sc_update[mod_id]->ul[i]->label;
-      break;
-    }
-  }
-  ul_slice->percentage = flexran_get_ul_slice_percentage(mod_id, slice_idx);
-  ul_slice->has_percentage = 1;
-  /*ul_slice->isolation = flexran_get_ul_slice_isolation(mod_id, slice_idx);*/
-  ul_slice->has_isolation = 0;
-  /*ul_slice->priority = flexran_get_ul_slice_priority(mod_id, slice_idx);*/
-  ul_slice->has_priority = 0;
-  ul_slice->first_rb = flexran_get_ul_slice_first_rb(mod_id, slice_idx);
-  ul_slice->has_first_rb = 1;
-  /*ul_slice-> = flexran_get_ul_slice_length_rb(mod_id, slice_idx);
-  ul_slice->has_length_rb = 0;*/
-  ul_slice->maxmcs = flexran_get_ul_slice_maxmcs(mod_id, slice_idx);
-  ul_slice->has_maxmcs = 1;
-  ul_slice->n_sorting = 0;
-  /*if (ul_slice->sorting) {
-    free(ul_slice->sorting);
-    ul_slice->sorting = NULL;
-  }
-  ul_slice->n_sorting = flexran_get_ul_slice_sorting(mod_id, slice_idx, &ul_slice->sorting);
-  if (ul_slice->n_sorting < 1) ul_slice->sorting = NULL;*/
-  /*ul_slice->accounting = flexran_get_ul_slice_accounting_policy(mod_id, slice_idx);*/
-  ul_slice->has_accounting = 0;
-  const char *s_name = flexran_get_ul_slice_scheduler(mod_id, slice_idx);
-  if (!ul_slice->scheduler_name
-      || strcmp(ul_slice->scheduler_name, s_name) != 0) {
-    ul_slice->scheduler_name = realloc(ul_slice->scheduler_name, strlen(s_name) + 1);
-    strcpy(ul_slice->scheduler_name, s_name);
-  }
-}
-
-int check_dl_sorting_update(Protocol__FlexDlSlice *old, Protocol__FlexDlSlice *new)
-{
-  /* sorting_update => true when old->n_sorting == 0 or different numbers of
-   * elements; otherwise will check * element-wise */
-  int sorting_update = old->n_sorting == 0 || (old->n_sorting != new->n_sorting);
-  for (int i = 0; i < old->n_sorting && !sorting_update; ++i) {
-    sorting_update = sorting_update || (new->sorting[i] != old->sorting[i]);
-  }
-  return sorting_update;
-}
-
-int check_ul_sorting_update(Protocol__FlexUlSlice *old, Protocol__FlexUlSlice *new)
-{
-  /* sorting_update => true when old->n_sorting == 0 or different numbers of
-   * elements; otherwise will check * element-wise */
-  int sorting_update = old->n_sorting == 0 || (old->n_sorting != new->n_sorting);
-  for (int i = 0; i < old->n_sorting && !sorting_update; ++i) {
-    sorting_update = sorting_update || (new->sorting[i] != old->sorting[i]);
-  }
-  return sorting_update;
-}
-
-void overwrite_slice_config(mid_t mod_id, Protocol__FlexSliceConfig *exist, Protocol__FlexSliceConfig *update)
-{
-  if (update->has_intraslice_share_active
-      && exist->intraslice_share_active != update->intraslice_share_active) {
-    LOG_I(FLEXRAN_AGENT, "[%d] update intraslice_share_active: %d -> %d\n",
-          mod_id, exist->intraslice_share_active, update->intraslice_share_active);
-    exist->intraslice_share_active = update->intraslice_share_active;
-    exist->has_intraslice_share_active = 1;
-  }
-  if (update->has_interslice_share_active
-      && exist->interslice_share_active != update->interslice_share_active) {
-    LOG_I(FLEXRAN_AGENT, "[%d] update interslice_share_active: %d -> %d\n",
-          mod_id, exist->interslice_share_active, update->interslice_share_active);
-    exist->interslice_share_active = update->interslice_share_active;
-    exist->has_interslice_share_active = 1;
-  }
-}
-
-void overwrite_slice_config_dl(mid_t mod_id, Protocol__FlexDlSlice *exist, Protocol__FlexDlSlice *update)
-{
-  if (update->label != exist->label) {
-    LOG_I(FLEXRAN_AGENT, "[%d][DL slice %d] update label: %d -> %d\n",
-          mod_id, update->id, exist->label, update->label);
-    exist->label = update->label;
-    exist->has_label = 1;
-  }
-  if (update->percentage != exist->percentage) {
-    LOG_I(FLEXRAN_AGENT, "[%d][DL slice %d] update percentage: %d -> %d\n",
-          mod_id, update->id, exist->percentage, update->percentage);
-    exist->percentage = update->percentage;
-    exist->has_percentage = 1;
-  }
-  if (update->isolation != exist->isolation) {
-    LOG_I(FLEXRAN_AGENT, "[%d][DL slice %d] update isolation: %d -> %d\n",
-          mod_id, update->id, exist->isolation, update->isolation);
-    exist->isolation = update->isolation;
-    exist->has_isolation = 1;
-  }
-  if (update->priority != exist->priority) {
-    LOG_I(FLEXRAN_AGENT, "[%d][DL slice %d] update priority: %d -> %d\n",
-          mod_id, update->id, exist->priority, update->priority);
-    exist->priority = update->priority;
-    exist->has_priority = 1;
-  }
-  if (update->position_low != exist->position_low) {
-    LOG_I(FLEXRAN_AGENT, "[%d][DL slice %d] update position_low: %d -> %d\n",
-          mod_id, update->id, exist->position_low, update->position_low);
-    exist->position_low = update->position_low;
-    exist->has_position_low = 1;
-  }
-  if (update->position_high != exist->position_high) {
-    LOG_I(FLEXRAN_AGENT, "[%d][DL slice %d] update position_high: %d -> %d\n",
-          mod_id, update->id, exist->position_high, update->position_high);
-    exist->position_high = update->position_high;
-    exist->has_position_high = 1;
-  }
-  if (update->maxmcs != exist->maxmcs) {
-    LOG_I(FLEXRAN_AGENT, "[%d][DL slice %d] update maxmcs: %d -> %d\n",
-          mod_id, update->id, exist->maxmcs, update->maxmcs);
-    exist->maxmcs = update->maxmcs;
-    exist->has_maxmcs = 1;
-  }
-  if (check_dl_sorting_update(exist, update)) {
-    LOG_I(FLEXRAN_AGENT, "[%d][DL slice %d] update sorting array\n", mod_id, update->id);
-    if (exist->n_sorting != update->n_sorting) {
-      exist->n_sorting = update->n_sorting;
-      exist->sorting = realloc(exist->sorting, exist->n_sorting * sizeof(Protocol__FlexDlSorting));
-      if (!exist->sorting) exist->n_sorting = 0;
-    }
-    for (int i = 0; i < exist->n_sorting; i++)
-      exist->sorting[i] = update->sorting[i];
-  }
-  if (update->accounting != exist->accounting) {
-    LOG_I(FLEXRAN_AGENT, "[%d][DL slice %d] update accounting: %d -> %d\n",
-          mod_id, update->id, exist->accounting, update->accounting);
-    exist->accounting = update->accounting;
-    exist->has_accounting = 1;
-  }
-  if (!exist->scheduler_name
-      || strcmp(update->scheduler_name, exist->scheduler_name) != 0) {
-    LOG_I(FLEXRAN_AGENT, "[%d][DL slice %d] update scheduler: %s -> %s\n",
-          mod_id, update->id, exist->scheduler_name, update->scheduler_name);
-    if (exist->scheduler_name) free(exist->scheduler_name);
-    exist->scheduler_name = strdup(update->scheduler_name);
-  }
-}
-
-void overwrite_slice_config_ul(mid_t mod_id, Protocol__FlexUlSlice *exist, Protocol__FlexUlSlice *update)
-{
-  if (update->label != exist->label) {
-    LOG_I(FLEXRAN_AGENT, "[%d][UL slice %d] update label: %d -> %d\n",
-          mod_id, update->id, exist->label, update->label);
-    exist->label = update->label;
-    exist->has_label = 1;
-  }
-  if (update->percentage != exist->percentage) {
-    LOG_I(FLEXRAN_AGENT, "[%d][UL slice %d] update percentage: %d -> %d\n",
-          mod_id, update->id, exist->percentage, update->percentage);
-    exist->percentage = update->percentage;
-    exist->has_percentage = 1;
-  }
-  if (update->isolation != exist->isolation) {
-    LOG_I(FLEXRAN_AGENT, "[%d][UL slice %d] update isolation: %d -> %d\n",
-          mod_id, update->id, exist->isolation, update->isolation);
-    exist->isolation = update->isolation;
-    exist->has_isolation = 1;
-  }
-  if (update->priority != exist->priority) {
-    LOG_I(FLEXRAN_AGENT, "[%d][UL slice %d] update priority: %d -> %d\n",
-          mod_id, update->id, exist->priority, update->priority);
-    exist->priority = update->priority;
-    exist->has_priority = 1;
-  }
-  if (update->first_rb != exist->first_rb) {
-    LOG_I(FLEXRAN_AGENT, "[%d][UL slice %d] update first_rb: %d -> %d\n",
-	  mod_id, update->id, exist->first_rb, update->first_rb);
-    exist->first_rb = update ->first_rb;
-    exist->has_first_rb = 1;
-  }
-  /*if (update->lenght_rb != exist->lenght_rb) {
-    LOG_I(FLEXRAN_AGENT, "[%d][UL slice %d] update lenght_rb: %d -> %d\n",
-          mod_id, update->id, exist->lenght_rb, update->lenght_rb);
-    exist->lenght_rb = update->lenght_rb;
-  }*/
-  if (update->maxmcs != exist->maxmcs) {
-    LOG_I(FLEXRAN_AGENT, "[%d][UL slice %d] update maxmcs: %d -> %d\n",
-          mod_id, update->id, exist->maxmcs, update->maxmcs);
-    exist->maxmcs = update->maxmcs;
-    exist->has_maxmcs = 1;
-  }
-  /* TODO
-  int sorting_update = 0;
-  int n = min(exist->n_sorting, update->n_sorting);
-  int i = 0;
-  while (i < n && !sorting_update) {
-    sorting_update = sorting_update || (update->sorting[i] != exist->sorting[i]);
-    i++;
-  }
-  if (sorting_update) {
-    LOG_I(FLEXRAN_AGENT, "[%d][UL slice %d] update sorting array\n", update->id, mod_id);
-    if (exist->n_sorting != update->n_sorting)
-      LOG_W(FLEXRAN_AGENT, "[%d][UL slice %d] only writing %d elements\n",
-          mod_id, update->id, n);
-    for (i = 0; i < n; i++)
-      exist->sorting[i] = update->sorting[i];
-  }
-  */
-  if (update->accounting != exist->accounting) {
-    LOG_I(FLEXRAN_AGENT, "[%d][UL slice %d] update accounting: %d -> %d\n",
-          mod_id, update->id, exist->accounting, update->accounting);
-    exist->accounting = update->accounting;
-    exist->has_accounting = 1;
-  }
-  if (!exist->scheduler_name
-      || strcmp(update->scheduler_name, exist->scheduler_name) != 0) {
-    LOG_I(FLEXRAN_AGENT, "[%d][UL slice %d] update scheduler: %s -> %s\n",
-          mod_id, update->id, exist->scheduler_name, update->scheduler_name);
-    if (exist->scheduler_name) free(exist->scheduler_name);
-    exist->scheduler_name = strdup(update->scheduler_name);
-  }
-}
-
-void fill_dl_slice(mid_t mod_id, Protocol__FlexDlSlice *s, Protocol__FlexDlSlice *from)
-{
-  /* function fills slice with information from another slice or with default
-   * values (currently slice 0) if from is NULL */
-  /* TODO fill the slice depending on the chosen label */
-  if (!s->has_label) {
-    s->has_label = 1;
-    s->label = from ? from->label : sc_update[mod_id]->dl[0]->label;
-  }
-  if (!s->has_percentage) {
-    s->has_percentage = 1;
-    s->percentage = from ? from->percentage : sc_update[mod_id]->dl[0]->percentage;
-  }
-  if (!s->has_isolation) {
-    s->has_isolation = 1;
-    s->isolation = from ? from->isolation : sc_update[mod_id]->dl[0]->isolation;
-  }
-  if (!s->has_priority) {
-    s->has_priority = 1;
-    s->priority = from ? from->priority : sc_update[mod_id]->dl[0]->priority;
-  }
-  if (!s->has_position_low) {
-    s->has_position_low = 1;
-    s->position_low = from ? from->position_low : sc_update[mod_id]->dl[0]->position_low;
-  }
-  if (!s->has_position_high) {
-    s->has_position_high = 1;
-    s->position_high = from ? from->position_high : sc_update[mod_id]->dl[0]->position_high;
-  }
-  if (!s->has_maxmcs) {
-    s->has_maxmcs = 1;
-    s->maxmcs = from ? from->maxmcs : sc_update[mod_id]->dl[0]->maxmcs;
-  }
-  if (s->n_sorting == 0) {
-    s->n_sorting = from ? from->n_sorting : sc_update[mod_id]->dl[0]->n_sorting;
-    s->sorting = calloc(s->n_sorting, sizeof(Protocol__FlexDlSorting));
-    if (!s->sorting) s->n_sorting = 0;
-    for (int i = 0; i < s->n_sorting; ++i)
-      s->sorting[i] = from ? from->sorting[i] : sc_update[0]->dl[0]->sorting[i];
-  }
-  if (!s->has_accounting) {
-    s->accounting = from ? from->accounting : sc_update[mod_id]->dl[0]->accounting;
-  }
-  if (!s->scheduler_name) {
-    s->scheduler_name = strdup(from ? from->scheduler_name : sc_update[mod_id]->dl[0]->scheduler_name);
-  }
-}
-
-Protocol__FlexDlSlice *get_existing_dl_slice(mid_t mod_id, int id)
-{
-  for (int i = 0; i < sc_update[mod_id]->n_dl; ++i) {
-    if (id == sc_update[mod_id]->dl[i]->id) {
-      return sc_update[mod_id]->dl[i];
-    }
-  }
-  return NULL;
-}
-
-Protocol__FlexDlSlice *create_new_dl_slice(mid_t mod_id, int id)
-{
-  LOG_I(FLEXRAN_AGENT,
-        "[%d] Creating DL slice with ID %d, taking default values from DL slice 0\n",
-        mod_id, id);
-  Protocol__FlexDlSlice *to = sc_update[mod_id]->dl[sc_update[mod_id]->n_dl];
-  sc_update[mod_id]->n_dl++;
-  AssertFatal(sc_update[mod_id]->n_dl <= 10,
-              "cannot create more than 10\n");
-  to->id = id;
-  return to;
-}
-
-void fill_ul_slice(mid_t mod_id, Protocol__FlexUlSlice *s, Protocol__FlexUlSlice *from)
-{
-  /* function fills slice with information from another slice or with default
-   * values (currently slice 0) if from is NULL */
-  /* TODO fill the slice depending on the chosen label */
-  if (!s->has_label) {
-    s->has_label = 1;
-    s->label = from ? from->label : sc_update[mod_id]->ul[0]->label;
-  }
-  if (!s->has_percentage) {
-    s->has_percentage = 1;
-    s->percentage = from ? from->percentage : sc_update[mod_id]->ul[0]->percentage;
-  }
-  if (!s->has_isolation) {
-    s->has_isolation = 1;
-    s->isolation = from ? from->isolation : sc_update[mod_id]->ul[0]->isolation;
-  }
-  if (!s->has_priority) {
-    s->has_priority = 1;
-    s->priority = from ? from->priority : sc_update[mod_id]->ul[0]->priority;
-  }
-  if (!s->has_first_rb) {
-    s->has_first_rb = 1;
-    s->first_rb = from ? from->first_rb : sc_update[mod_id]->ul[0]->first_rb;
-  }
-  if (!s->has_maxmcs) {
-    s->has_maxmcs = 1;
-    s->maxmcs = from ? from->maxmcs : sc_update[mod_id]->ul[0]->maxmcs;
-  }
-  if (s->n_sorting == 0) {
-    s->n_sorting = from ? from->n_sorting : sc_update[0]->ul[0]->n_sorting;
-    s->sorting = calloc(s->n_sorting, sizeof(Protocol__FlexUlSorting));
-    if (!s->sorting) s->n_sorting = 0;
-    for (int i = 0; i < s->n_sorting; ++i)
-      s->sorting[i] = from ? from->sorting[i] : sc_update[0]->ul[0]->sorting[i];
-  }
-  if (!s->has_accounting) {
-    s->accounting = from ? from->accounting : sc_update[0]->ul[0]->accounting;
-  }
-  if (!s->scheduler_name) {
-    s->scheduler_name = strdup(from ? from->scheduler_name : sc_update[mod_id]->ul[0]->scheduler_name);
-  }
-}
-
-Protocol__FlexUlSlice *get_existing_ul_slice(mid_t mod_id, int id)
-{
-  for (int i = 0; i < sc_update[mod_id]->n_ul; ++i) {
-    if (id == sc_update[mod_id]->ul[i]->id) {
-      return sc_update[mod_id]->ul[i];
-    }
-  }
-  return NULL;
-}
-
-Protocol__FlexUlSlice *create_new_ul_slice(mid_t mod_id, int id)
-{
-  LOG_I(FLEXRAN_AGENT,
-        "[%d] Creating UL slice with ID %d, taking default values from UL slice 0\n",
-        mod_id, id);
-  Protocol__FlexUlSlice *to = sc_update[mod_id]->ul[sc_update[mod_id]->n_ul];
-  sc_update[mod_id]->n_ul++;
-  AssertFatal(sc_update[mod_id]->n_ul <= 10,
-              "cannot create more than 10\n");
-  to->id = id;
-  return to;
-}
-
 void prepare_update_slice_config(mid_t mod_id, Protocol__FlexSliceConfig *sup)
 {
-  int verified = 1;
-  if (!sc_update[mod_id]) {
-    LOG_E(FLEXRAN_AGENT, "Can not update slice policy (no existing slice profile)\n");
-    return;
-  }
-
-  pthread_mutex_lock(&sc_update_mtx);
-  /* no need for tests in the current state as there are only two protobuf
-    * bools for intra-/interslice sharing. The function applies new values if
-    * applicable */
-  overwrite_slice_config(mod_id, sc_update[mod_id], sup);
-
-  if (sup->n_dl == 0) {
-    LOG_I(FLEXRAN_AGENT, "[%d] no DL slice configuration in flex_slice_config message\n", mod_id);
-  } else {
-    /* verify slice parameters */
-    for (int i = 0; i < sup->n_dl; i++) {
-      if (!sup->dl[i]->has_id) {
-        verified = 0;
-        break;
-      }
-      Protocol__FlexDlSlice *dls = get_existing_dl_slice(mod_id, sup->dl[i]->id);
-      /* fill up so that the slice is complete. This way, we don't need to
-       * worry about it later */
-      fill_dl_slice(mod_id, sup->dl[i], dls);
-      verified = verified && flexran_verify_dl_slice(mod_id, sup->dl[i]);
-      if (!verified) break;
-    }
-
-    /* verify group-based parameters (e.g. sum percentage should not exceed
-     * 100%). Can be used to perform admission control */
-    verified = verified && flexran_verify_group_dl_slices(mod_id,
-        sc_update[mod_id]->dl, sc_update[mod_id]->n_dl, sup->dl, sup->n_dl);
-
-    if (verified) {
-      for (int i = 0; i < sup->n_dl; i++) {
-        /* if all verifications were successful, get existing slice for ID or
-         * create new one and overwrite with the update */
-        Protocol__FlexDlSlice *dls = get_existing_dl_slice(mod_id, sup->dl[i]->id);
-        if (!dls) dls = create_new_dl_slice(mod_id, sup->dl[i]->id);
-        overwrite_slice_config_dl(mod_id, dls, sup->dl[i]);
-      }
-    } else {
-      LOG_E(FLEXRAN_AGENT, "[%d] DL slice verification failed, refusing application\n", mod_id);
-    }
-  }
-
-  verified = 1;
-  if (sup->n_ul == 0) {
-    LOG_I(FLEXRAN_AGENT, "[%d] no UL slice configuration in flex_slice_config message\n", mod_id);
-  } else {
-    /* verify slice parameters */
-    for (int i = 0; i < sup->n_ul; i++) {
-      if (!sup->ul[i]->has_id) {
-        verified = 0;
-        break;
-      }
-      Protocol__FlexUlSlice *uls = get_existing_ul_slice(mod_id, sup->ul[i]->id);
-      /* fill up so that the slice is complete. This way, we don't need to
-       * worry about it later */
-      fill_ul_slice(mod_id, sup->ul[i], uls);
-      verified = verified && flexran_verify_ul_slice(mod_id, sup->ul[i]);
-      if (!verified) break;
-    }
-
-    /* verify group-based parameters (e.g. sum percentage should not exceed
-     * 100%). Can be used to perform admission control */
-    verified = verified && flexran_verify_group_ul_slices(mod_id,
-        sc_update[mod_id]->ul, sc_update[mod_id]->n_ul, sup->ul, sup->n_ul);
-
-    if (verified) {
-      for (int i = 0; i < sup->n_ul; i++) {
-        /* if all verifications were successful, get existing slice for ID or
-         * create new one and overwrite with the update */
-        Protocol__FlexUlSlice *uls = get_existing_ul_slice(mod_id, sup->ul[i]->id);
-        if (!uls) uls = create_new_ul_slice(mod_id, sup->ul[i]->id);
-        overwrite_slice_config_ul(mod_id, uls, sup->ul[i]);
-      }
-    } else {
-      LOG_E(FLEXRAN_AGENT, "[%d] UL slice verification failed, refusing application\n", mod_id);
-    }
-  }
-  pthread_mutex_unlock(&sc_update_mtx);
-
-  perform_slice_config_update_count = 1;
-}
-
-int apply_new_slice_config(mid_t mod_id, Protocol__FlexSliceConfig *olds, Protocol__FlexSliceConfig *news)
-{
-  /* not setting the old configuration is intentional, as it will be picked up
-   * later when reading the configuration. There is thus a direct feedback
-   * whether it has been set. */
-  int changes = 0;
-  if (olds->intraslice_share_active != news->intraslice_share_active) {
-    flexran_set_intraslice_sharing_active(mod_id, news->intraslice_share_active);
-    changes++;
-  }
-  if (olds->interslice_share_active != news->interslice_share_active) {
-    flexran_set_interslice_sharing_active(mod_id, news->interslice_share_active);
-    changes++;
-  }
-  return changes;
-}
-
-int apply_new_slice_dl_config(mid_t mod_id, Protocol__FlexDlSlice *oldc, Protocol__FlexDlSlice *newc)
-{
-  /* not setting the old configuration is intentional, as it will be picked up
-   * later when reading the configuration. There is thus a direct feedback
-   * whether it has been set. */
-  int changes = 0;
-  int slice_idx = flexran_find_dl_slice(mod_id, newc->id);
-  if (slice_idx < 0) {
-    LOG_W(FLEXRAN_AGENT, "[%d] cannot find index for slice ID %d\n", mod_id, newc->id);
-    return 0;
-  }
-  if (oldc->percentage != newc->percentage) {
-    flexran_set_dl_slice_percentage(mod_id, slice_idx, newc->percentage);
-    changes++;
-  }
-  if (oldc->isolation != newc->isolation) {
-    flexran_set_dl_slice_isolation(mod_id, slice_idx, newc->isolation);
-    changes++;
-  }
-  if (oldc->priority != newc->priority) {
-    flexran_set_dl_slice_priority(mod_id, slice_idx, newc->priority);
-    changes++;
-  }
-  if (oldc->position_low != newc->position_low) {
-    flexran_set_dl_slice_position_low(mod_id, slice_idx, newc->position_low);
-    changes++;
-  }
-  if (oldc->position_high != newc->position_high) {
-    flexran_set_dl_slice_position_high(mod_id, slice_idx, newc->position_high);
-    changes++;
-  }
-  if (oldc->maxmcs != newc->maxmcs) {
-    flexran_set_dl_slice_maxmcs(mod_id, slice_idx, newc->maxmcs);
-    changes++;
-  }
-  if (check_dl_sorting_update(oldc, newc)) {
-    flexran_set_dl_slice_sorting(mod_id, slice_idx, newc->sorting, newc->n_sorting);
-    changes++;
-  }
-  if (oldc->accounting != newc->accounting) {
-    flexran_set_dl_slice_accounting_policy(mod_id, slice_idx, newc->accounting);
-    changes++;
-  }
-  if (!oldc->scheduler_name
-      || strcmp(oldc->scheduler_name, newc->scheduler_name) != 0) {
-    int ret = flexran_set_dl_slice_scheduler(mod_id, slice_idx, newc->scheduler_name);
-    AssertFatal(ret, "could not set DL slice scheduler for slice %d idx %d\n",
-                newc->id, slice_idx);
-    changes++;
-  }
-  return changes;
 }
 
-int apply_new_slice_ul_config(mid_t mod_id, Protocol__FlexUlSlice *oldc, Protocol__FlexUlSlice *newc)
-{
-  /* not setting the old configuration is intentional, as it will be picked up
-   * later when reading the configuration. There is thus a direct feedback
-   * whether it has been set. */
-  int changes = 0;
-  int slice_idx = flexran_find_ul_slice(mod_id, newc->id);
-  if (slice_idx < 0) {
-    LOG_W(FLEXRAN_AGENT, "[%d] cannot find index for slice ID %d\n", mod_id, newc->id);
-    return 0;
-  }
-  if (oldc->percentage != newc->percentage) {
-    flexran_set_ul_slice_percentage(mod_id, slice_idx, newc->percentage);
-    changes++;
-  }
-  if (oldc->isolation != newc->isolation) {
-    /*flexran_set_ul_slice_isolation(mod_id, slice_idx, newc->isolation);
-     *changes++;*/
-    LOG_W(FLEXRAN_AGENT, "[%d][UL slice %d] setting isolation is not supported\n",
-          mod_id, newc->id);
-  }
-  if (oldc->priority != newc->priority) {
-    /*flexran_set_ul_slice_priority(mod_id, slice_idx, newc->priority);
-     *changes++;*/
-    LOG_W(FLEXRAN_AGENT, "[%d][UL slice %d] setting the priority is not supported\n",
-          mod_id, newc->id);
-  }
-  if (oldc->first_rb != newc->first_rb) {
-    flexran_set_ul_slice_first_rb(mod_id, slice_idx, newc->first_rb);
-    changes++;
-  }
-  /*if (oldc->length_rb != newc->length_rb) {
-    flexran_set_ul_slice_length_rb(mod_id, slice_idx, newc->length_rb);
-    changes++;
-    LOG_W(FLEXRAN_AGENT, "[%d][UL slice %d] setting length_rb is not supported\n",
-          mod_id, newc->id);
-  }*/
-  if (oldc->maxmcs != newc->maxmcs) {
-    flexran_set_ul_slice_maxmcs(mod_id, slice_idx, newc->maxmcs);
-    changes++;
-  }
-  /*if (check_ul_sorting_update(oldc, newc)) {
-    flexran_set_ul_slice_sorting(mod_id, slice_idx, newc->sorting, n);
-    changes++;
-    LOG_W(FLEXRAN_AGENT, "[%d][UL slice %d] setting the sorting is not supported\n",
-        mod_id, newc->id);
-  }*/
-  if (oldc->accounting != newc->accounting) {
-    /*flexran_set_ul_slice_accounting_policy(mod_id, slice_idx, newc->accounting);
-     *changes++;*/
-    LOG_W(FLEXRAN_AGENT, "[%d][UL slice %d] setting the accounting is not supported\n",
-          mod_id, newc->id);
-  }
-  if (!oldc->scheduler_name
-      || strcmp(oldc->scheduler_name, newc->scheduler_name) != 0) {
-    int ret = flexran_set_ul_slice_scheduler(mod_id, slice_idx, newc->scheduler_name);
-    AssertFatal(ret, "could not set DL slice scheduler for slice %d idx %d\n",
-                newc->id, slice_idx);
-    changes++;
-  }
-  return changes;
-}
 
 void prepare_ue_slice_assoc_update(mid_t mod_id, Protocol__FlexUeConfig *ue_config)
 {
@@ -1723,24 +1075,8 @@ int apply_ue_slice_assoc_update(mid_t mod_id)
       continue;
     }
     if (ue_slice_assoc_update[i]->has_dl_slice_id) {
-      int slice_idx = flexran_find_dl_slice(mod_id, ue_slice_assoc_update[i]->dl_slice_id);
-      if (flexran_dl_slice_exists(mod_id, slice_idx)) {
-        flexran_set_ue_dl_slice_idx(mod_id, ue_id, slice_idx);
-        changes++;
-      } else {
-        LOG_W(FLEXRAN_AGENT, "[%d] DL slice %d does not exist, refusing change\n",
-              mod_id, ue_slice_assoc_update[i]->dl_slice_id);
-      }
     }
     if (ue_slice_assoc_update[i]->has_ul_slice_id) {
-      int slice_idx = flexran_find_ul_slice(mod_id, ue_slice_assoc_update[i]->ul_slice_id);
-      if (flexran_ul_slice_exists(mod_id, slice_idx)) {
-        flexran_set_ue_ul_slice_idx(mod_id, ue_id, slice_idx);
-        changes++;
-      } else {
-        LOG_W(FLEXRAN_AGENT, "[%d] UL slice %d does not exist, refusing change\n",
-              mod_id, ue_slice_assoc_update[i]->ul_slice_id);
-      }
     }
   }
   n_ue_slice_assoc_updates = 0;
diff --git a/openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac_internal.h b/openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac_internal.h
index 957fe6065edfee892de34e17c436cbc84a275fc5..ef2a7e40a970437c4d3365d716ed710ed539b6a1 100644
--- a/openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac_internal.h
+++ b/openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac_internal.h
@@ -111,30 +111,10 @@ Protocol__FlexSliceConfig *flexran_agent_create_slice_config(int n_dl, int m_ul)
  * Protocol__FlexSliceConfig struct */
 void flexran_agent_read_slice_config(mid_t mod_id, Protocol__FlexSliceConfig *s);
 
-/* read the DL slice config via the RAN into a given Protocol__FlexDlSlice
- * struct */
-void flexran_agent_read_slice_dl_config(mid_t mod_id, int slice_idx, Protocol__FlexDlSlice *dl_slice);
-
-/* read the UL slice config via the RAN into a given Protocol__FlexUlSlice
- * struct */
-void flexran_agent_read_slice_ul_config(mid_t mod_id, int slice_idx, Protocol__FlexUlSlice *ul_slice);
-
 /* reads content of slice over the sc_update structure, so that it can be
  * applied later by performing a diff between slice_config and sc_update */
 void prepare_update_slice_config(mid_t mod_id, Protocol__FlexSliceConfig *slice);
 
-/* apply generic slice parameters (e.g. intra-/interslice sharing activated or
- * not) if there are changes. Returns the number of changed parameters. */
-int apply_new_slice_config(mid_t mod_id, Protocol__FlexSliceConfig *olds, Protocol__FlexSliceConfig *news);
-
-/* apply new configuration of slice in DL if there are changes between the
- * parameters. Returns the number of changed parameters. */
-int apply_new_slice_dl_config(mid_t mod_id, Protocol__FlexDlSlice *oldc, Protocol__FlexDlSlice *newc);
-
-/* apply new configuration of slice in UL if there are changes between the
- * parameters. Returns the number of changed parameters. */
-int apply_new_slice_ul_config(mid_t mod_id, Protocol__FlexUlSlice *oldc, Protocol__FlexUlSlice *newc);
-
 /* inserts a new ue_config into the structure keeping ue to slice association
  * updates and marks so it can be applied */
 void prepare_ue_slice_assoc_update(mid_t mod_id, Protocol__FlexUeConfig *ue_config);
diff --git a/openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac_slice_verification.c b/openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac_slice_verification.c
index f7f60541f5712d5a12b0d8892bd12cbb3045677f..6e54e155c260cb86d5358298409e26691ca8910a 100644
--- a/openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac_slice_verification.c
+++ b/openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac_slice_verification.c
@@ -28,346 +28,3 @@
 
 
 #include "flexran_agent_mac_slice_verification.h"
-
-/* overlap check for UL slices, helper type */
-struct sregion_s {
-  int start;
-  int length;
-};
-
-/* forward declaration of locally-used verification functions */
-int flexran_dl_slice_verify_pct(int pct);
-int flexran_dl_slice_verify_priority(int prio);
-int flexran_dl_slice_verify_position(int pos_low, int pos_high);
-int flexran_dl_slice_verify_maxmcs(int maxmcs);
-int flexran_ul_slice_verify_pct(int pct);
-int flexran_ul_slice_verify_priority(int prio);
-int flexran_ul_slice_verify_first_rb(int first_rb);
-int flexran_ul_slice_verify_maxmcs(int maxmcs);
-int check_ul_slice_overlap(mid_t mod_id, struct sregion_s *sr, int n);
-
-int flexran_verify_dl_slice(mid_t mod_id, Protocol__FlexDlSlice *dls)
-{
-  /* check mandatory parameters */
-  if (!dls->has_id) {
-    LOG_E(FLEXRAN_AGENT, "[%d] Incoming DL slice configuration has no ID\n", mod_id);
-    return 0;
-  }
-
-  /* verify parameters individualy */
-  /* label is enum */
-  if (!flexran_dl_slice_verify_pct(dls->percentage)) {
-    LOG_E(FLEXRAN_AGENT, "[%d][DL slice %d] illegal DL slice percentage (%d)\n",
-          mod_id, dls->id, dls->percentage);
-    return 0;
-  }
-  /* isolation is a protobuf bool */
-  if (!flexran_dl_slice_verify_priority(dls->priority)) {
-    LOG_E(FLEXRAN_AGENT, "[%d][DL slice %d] illegal DL slice priority (%d)\n",
-          mod_id, dls->id, dls->priority);
-    return 0;
-  }
-  if (!flexran_dl_slice_verify_position(dls->position_low, dls->position_high)) {
-    LOG_E(FLEXRAN_AGENT,
-          "[%d][DL slice %d] illegal DL slice position low (%d) and/or high (%d)\n",
-          mod_id, dls->id, dls->position_low, dls->position_high);
-    return 0;
-  }
-  if (!flexran_dl_slice_verify_maxmcs(dls->maxmcs)) {
-    LOG_E(FLEXRAN_AGENT, "[%d][DL slice %d] illegal DL slice max mcs %d\n",
-          mod_id, dls->id, dls->maxmcs);
-    return 0;
-  }
-  if (dls->n_sorting == 0) {
-    LOG_E(FLEXRAN_AGENT, "[%d][DL slice %d] no sorting in DL slice\n",
-          mod_id, dls->id);
-    return 0;
-  }
-  if (!dls->sorting) {
-    LOG_E(FLEXRAN_AGENT, "[%d][DL slice %d] no sorting found in DL slice\n",
-          mod_id, dls->id);
-    return 0;
-  }
-  /* sorting is an enum */
-  /* accounting is an enum */
-  if (!dls->scheduler_name) {
-    LOG_E(FLEXRAN_AGENT, "[%d][DL slice %d] no scheduler name found\n",
-          mod_id, dls->id);
-    return 0;
-  }
-  if (strcmp(dls->scheduler_name, "schedule_ue_spec") != 0) {
-    LOG_E(FLEXRAN_AGENT, "[%d][DL slice %d] setting the scheduler to something "
-          "different than schedule_ue_spec is currently not allowed\n",
-          mod_id, dls->id);
-    return 0;
-  }
-
-  return 1;
-}
-
-int flexran_verify_group_dl_slices(mid_t mod_id, Protocol__FlexDlSlice **existing,
-    int n_ex, Protocol__FlexDlSlice **update, int n_up)
-{
-  int i, j, n;
-  int pct, pct_orig;
-  /* for every update, array points to existing slice, or NULL if update
-   * creates new slice */
-  Protocol__FlexDlSlice *s[n_up];
-  for (i = 0; i < n_up; i++) {
-    s[i] = NULL;
-    for (j = 0; j < n_ex; j++) {
-      if (existing[j]->id == update[i]->id)
-        s[i] = existing[j];
-    }
-  }
-
-  /* check that number of created and number of added slices in total matches
-   * [1,10] */
-  n = n_ex;
-  for (i = 0; i < n_up; i++) {
-    /* new slice */
-    if (!s[i]) n += 1;
-    /* slice will be deleted */
-    else if (s[i]->percentage == 0) n -= 1;
-    /* else "only" an update */
-  }
-
-  if (n < 1 || n > 10) {
-    LOG_E(FLEXRAN_AGENT, "[%d] Illegal number of resulting DL slices (%d -> %d)\n",
-          mod_id, n_ex, n);
-    return 0;
-  }
-
-  /* check that the sum of all slices percentages (including removed/added
-   * slices) matches [1,100] */
-  pct = 0;
-  for (i = 0; i < n_ex; i++) {
-    pct += existing[i]->percentage;
-  }
-  pct_orig = pct;
-  for (i = 0; i < n_up; i++) {
-    /* if there is an existing slice, subtract its percentage and add the
-     * update's percentage */
-    if (s[i])
-      pct -= s[i]->percentage;
-    pct += update[i]->percentage;
-  }
-  if (pct < 1 || pct > 100) {
-    LOG_E(FLEXRAN_AGENT,
-          "[%d] invalid total RB share for DL slices (%d%% -> %d%%)\n",
-          mod_id, pct_orig, pct);
-    return 0;
-  }
-
-  return 1;
-}
-
-int flexran_verify_ul_slice(mid_t mod_id, Protocol__FlexUlSlice *uls)
-{
-  /* check mandatory parameters */
-  if (!uls->has_id) {
-    LOG_E(FLEXRAN_AGENT, "[%d] Incoming UL slice configuration has no ID\n", mod_id);
-    return 0;
-  }
-
-  /* verify parameters individually */
-  /* label is enum */
-  if (!flexran_ul_slice_verify_pct(uls->percentage)) {
-    LOG_E(FLEXRAN_AGENT, "[%d][UL slice %d] illegal UL slice percentage (%d)\n",
-          mod_id, uls->id, uls->percentage);
-    return 0;
-  }
-  /* isolation is a protobuf bool */
-  if (!flexran_ul_slice_verify_priority(uls->priority)) {
-    LOG_E(FLEXRAN_AGENT, "[%d][UL slice %d] illegal UL slice percentage (%d)\n",
-          mod_id, uls->id, uls->priority);
-    return 0;
-  }
-  if (!flexran_ul_slice_verify_first_rb(uls->first_rb)) {
-    LOG_E(FLEXRAN_AGENT, "[%d][UL slice %d] illegal UL slice first RB (%d)\n",
-          mod_id, uls->id, uls->first_rb);
-    return 0;
-  }
-  if (!flexran_ul_slice_verify_maxmcs(uls->maxmcs)) {
-    LOG_E(FLEXRAN_AGENT, "[%d][UL slice %d] illegal UL slice max mcs (%d)\n",
-          mod_id, uls->id, uls->maxmcs);
-    return 0;
-  }
-  /* TODO
-  if (uls->n_sorting == 0) {
-    LOG_E(FLEXRAN_AGENT, "[%d][UL slice %d] no sorting in UL slice\n",
-          mod_id, uls->id);
-    return 0;
-  }
-  if (!uls->sorting) {
-    LOG_E(FLEXRAN_AGENT, "[%d][UL slice %d] no sorting found in UL slice\n",
-          mod_id, uls->id);
-    return 0;
-  }
-  */
-  /* sorting is an enum */
-  /* accounting is an enum */
-  if (!uls->scheduler_name) {
-    LOG_E(FLEXRAN_AGENT, "[%d][UL slice %d] no scheduler name found\n",
-          mod_id, uls->id);
-    return 0;
-  }
-  if (strcmp(uls->scheduler_name, "schedule_ulsch_rnti") != 0) {
-    LOG_E(FLEXRAN_AGENT, "[%d][UL slice %d] setting the scheduler to something "
-          "different than schedule_ulsch_rnti is currently not allowed\n",
-          mod_id, uls->id);
-    return 0;
-  }
-
-  return 1;
-}
-
-int flexran_verify_group_ul_slices(mid_t mod_id, Protocol__FlexUlSlice **existing,
-    int n_ex, Protocol__FlexUlSlice **update, int n_up)
-{
-  int i, j, n;
-  int pct, pct_orig;
-  /* for every update, array "s" points to existing slice, or NULL if update
-   * creates new slice; array "offs" gives the offset of this slice */
-  Protocol__FlexUlSlice *s[n_up];
-  int offs[n_up];
-  for (i = 0; i < n_up; i++) {
-    s[i] = NULL;
-    offs[i] = 0;
-    for (j = 0; j < n_ex; j++) {
-      if (existing[j]->id == update[i]->id) {
-        s[i] = existing[j];
-        offs[i] = j;
-      }
-    }
-  }
-
-  /* check that number of created and number of added slices in total matches
-   * [1,10] */
-  n = n_ex;
-  for (i = 0; i < n_up; i++) {
-    /* new slice */
-    if (!s[i]) n += 1;
-    /* slice will be deleted */
-    else if (s[i]->percentage == 0) n -= 1;
-    /* else "only" an update */
-  }
-
-  if (n < 1 || n > 10) {
-    LOG_E(FLEXRAN_AGENT, "[%d] Illegal number of resulting UL slices (%d -> %d)\n",
-          mod_id, n_ex, n);
-    return 0;
-  }
-
-  /* check that the sum of all slices percentages (including removed/added
-   * slices) matches [1,100] */
-  pct = 0;
-  for (i = 0; i < n_ex; i++) {
-    pct += existing[i]->percentage;
-  }
-  pct_orig = pct;
-  for (i = 0; i < n_up; i++) {
-    /* if there is an existing slice, subtract its percentage and add the
-     * update's percentage */
-    if (s[i])
-      pct -= s[i]->percentage;
-    pct += update[i]->percentage;
-  }
-  if (pct < 1 || pct > 100) {
-    LOG_E(FLEXRAN_AGENT, "[%d] invalid total RB share (%d%% -> %d%%)\n",
-          mod_id, pct_orig, pct);
-    return 0;
-  }
-
-  /* check that there is no overlap in slices resulting as the combination of
-   * first_rb and percentage */
-  struct sregion_s sregion[n];
-  const int N_RB = flexran_get_N_RB_UL(mod_id, 0); /* assume PCC */
-  int k = n_ex;
-  for (i = 0; i < n_ex; i++) {
-    sregion[i].start = existing[i]->first_rb;
-    sregion[i].length = existing[i]->percentage * N_RB / 100;
-  }
-  for (i = 0; i < n_up; i++) {
-    ptrdiff_t d = s[i] ? offs[i] : k++;
-    AssertFatal(d >= 0 && d < k, "illegal pointer offset (%ld, k=%d)\n", d, k);
-    sregion[d].start = update[i]->first_rb;
-    sregion[d].length = update[i]->percentage * N_RB / 100;
-  }
-  AssertFatal(k == n, "illegal number of slices while calculating overlap\n");
-  if (!check_ul_slice_overlap(mod_id, sregion, k)) {
-    LOG_E(FLEXRAN_AGENT, "[%d] UL slices are overlapping\n", mod_id);
-    return 0;
-  }
-
-  return 1;
-}
-
-int flexran_dl_slice_verify_pct(int pct)
-{
-  return pct >= 0 && pct <= 100;
-}
-
-int flexran_dl_slice_verify_priority(int prio)
-{
-  return prio >= 0;
-}
-
-int flexran_dl_slice_verify_position(int pos_low, int pos_high)
-{
-  return pos_low < pos_high && pos_low >= 0 && pos_high <= N_RBG_MAX;
-}
-
-int flexran_dl_slice_verify_maxmcs(int maxmcs)
-{
-  return maxmcs >= 0 && maxmcs <= 28;
-}
-
-int flexran_ul_slice_verify_pct(int pct)
-{
-  return pct >= 0 && pct <= 100;
-}
-
-int flexran_ul_slice_verify_priority(int prio)
-{
-  return prio >= 0;
-}
-
-int flexran_ul_slice_verify_first_rb(int first_rb)
-{
-  return first_rb >= 0 && first_rb < 100;
-}
-
-int flexran_ul_slice_verify_maxmcs(int maxmcs)
-{
-  return maxmcs >= 0 && maxmcs <= 20;
-}
-
-int sregion_compare(const void *_a, const void *_b)
-{
-  const struct sregion_s *a = (const struct sregion_s *)_a;
-  const struct sregion_s *b = (const struct sregion_s *)_b;
-  const int res = a->start - b->start;
-  if (res < 0)       return -1;
-  else if (res == 0) return 0;
-  else               return 1;
-}
-
-int check_ul_slice_overlap(mid_t mod_id, struct sregion_s *sr, int n)
-{
-  int i;
-  int overlap, op, u;
-  const int N_RB = flexran_get_N_RB_UL(mod_id, 0); /* assume PCC */
-  qsort(sr, n, sizeof(sr[0]), sregion_compare);
-  for (i = 0; i < n; i++) {
-    u = i == n-1 ? N_RB : sr[i+1].start;
-    AssertFatal(sr[i].start <= u, "unsorted slice list\n");
-    overlap = sr[i].start + sr[i].length - u;
-    if (overlap <= 0) continue;
-    op = overlap * 100 / sr[i].length;
-    LOG_W(FLEXRAN_AGENT, "[%d] slice overlap of %d%% detected\n", mod_id, op);
-    if (op >= 10) /* more than 10% overlap -> refuse */
-      return 0;
-  }
-  return 1;
-}
diff --git a/openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac_slice_verification.h b/openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac_slice_verification.h
index a8f4030d3664be1e1388d8d42cae8feed9a4dd90..c9e66b6f88236c9410f19a429ca916fafdf07f20 100644
--- a/openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac_slice_verification.h
+++ b/openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac_slice_verification.h
@@ -29,9 +29,3 @@
 #include "flexran_agent_common_internal.h"
 #include "flexran_agent_mac_internal.h"
 
-int flexran_verify_dl_slice(mid_t mod_id, Protocol__FlexDlSlice *dls);
-int flexran_verify_group_dl_slices(mid_t mod_id, Protocol__FlexDlSlice **existing,
-    int n_ex, Protocol__FlexDlSlice **update, int n_up);
-int flexran_verify_ul_slice(mid_t mod_id, Protocol__FlexUlSlice *uls);
-int flexran_verify_group_ul_slices(mid_t mod_id, Protocol__FlexUlSlice **existing,
-    int n_ex, Protocol__FlexUlSlice **update, int n_up);
diff --git a/openair2/ENB_APP/MESSAGES/V2/config_common.proto b/openair2/ENB_APP/MESSAGES/V2/config_common.proto
index 733d883c92c0ed5af68e848051e6d2783ff937d6..e5d01ebdc05b3ac4ea5ea783751aa0292c413405 100644
--- a/openair2/ENB_APP/MESSAGES/V2/config_common.proto
+++ b/openair2/ENB_APP/MESSAGES/V2/config_common.proto
@@ -61,83 +61,6 @@ enum flex_qam {
 //
 // Slice config related structures and enums
 //
-enum flex_dl_sorting {
-
-	CR_ROUND = 0;	// Highest HARQ first
-	CR_SRB12 = 1;	// Highest SRB1+2 first
-	CR_HOL   = 2;	// Highest HOL first
-	CR_LC    = 3;	// Greatest RLC buffer first
-	CR_CQI   = 4;	// Highest CQI first
-	CR_LCP   = 5;	// Highest LC priority first
-}
-
-enum flex_ul_sorting {
-	CRU_ROUND = 0;	// Highest HARQ first
-	CRU_BUF   = 1;	// Highest BSR first
-	CRU_BTS   = 2;	// More bytes to schedule first
-	CRU_MCS   = 3;  // Highest MCS first
-	CRU_LCP   = 4;  // Highest LC priority first
-	CRU_HOL   = 5;  // Highest HOL first
-}
-
-enum flex_dl_accounting_policy {
-	POL_FAIR   = 0;
-	POL_GREEDY = 1;
-	POL_NUM    = 2;
-}
-
-enum flex_ul_accounting_policy {
-	POLU_FAIR   = 0;
-	POLU_GREEDY = 1;
-	POLU_NUM    = 2;
-}
-
-enum flex_slice_label {
-	xMBB  = 0;
-	URLLC = 1;
-	mMTC  = 2;
-	xMTC  = 3;
-	Other = 4;
-}
-
-message flex_dl_slice {
-	optional uint32 id = 1;
-	optional flex_slice_label label = 2;
-	// should be between 0 and 100
-	optional uint32 percentage = 3;
-	// whether this slice should be exempted form interslice sharing
-	optional bool   isolation = 4;
-	// increasing value means increasing prio
-	optional uint32 priority = 5;
-	// min and max RB to use (in frequency) in the range [0, N_RBG_MAX]
-	optional uint32 position_low = 6;
-	optional uint32 position_high = 7;
-	// maximum MCS to be allowed in this slice
-	optional uint32 maxmcs = 8;
-	repeated flex_dl_sorting sorting = 9;
-	optional flex_dl_accounting_policy accounting = 10;
-	optional string scheduler_name = 11;
-}
-
-message flex_ul_slice {
-	optional uint32 id = 1;
-	optional flex_slice_label label = 2;
-	// should be between 0 and 100
-	optional uint32 percentage = 3;
-	// whether this slice should be exempted form interslice sharing
-	optional bool   isolation = 4;
-	// increasing value means increasing prio
-	optional uint32 priority = 5;
-	// RB start to use (in frequency) in the range [0, N_RB_MAX]
-	optional uint32 first_rb = 6;
-	// TODO RB number
-	//optional uint32 length_rb = 7;
-	// maximum MCS to be allowed in this slice
-	optional uint32 maxmcs = 8;
-	repeated flex_ul_sorting sorting = 9;
-	optional flex_ul_accounting_policy accounting = 10;
-	optional string scheduler_name = 11;
-}
 
 //
 // UE config related structures and enums
diff --git a/openair2/ENB_APP/MESSAGES/V2/config_messages.proto b/openair2/ENB_APP/MESSAGES/V2/config_messages.proto
index 324153613d396307e3a37bce643bdcb60220e19e..1a66a4f20f121d0029a56cda9fc2ec9d4a9e8b37 100644
--- a/openair2/ENB_APP/MESSAGES/V2/config_messages.proto
+++ b/openair2/ENB_APP/MESSAGES/V2/config_messages.proto
@@ -49,14 +49,6 @@ message flex_cell_config {
 }
 
 message flex_slice_config {
-	// whether remaining RBs after first intra-slice allocation will
-	// be allocated to UEs of the same slice
-	optional bool   intraslice_share_active = 3;
-	// whether remaining RBs after slice allocation will be allocated
-	// to UEs of another slice. Isolated slices will be ignored.
-	optional bool   interslice_share_active = 4;
-	repeated flex_dl_slice dl = 1;
-	repeated flex_ul_slice ul = 2;
 }
 
 message flex_ue_config {
diff --git a/openair2/ENB_APP/flexran_agent_common.c b/openair2/ENB_APP/flexran_agent_common.c
index e77b2fb386ce061780bb4298d989dfa4c0964447..3dd9f5b957e793183809da882009f14cf8a3af6f 100644
--- a/openair2/ENB_APP/flexran_agent_common.c
+++ b/openair2/ENB_APP/flexran_agent_common.c
@@ -316,25 +316,7 @@ int flexran_agent_destroy_enb_config_reply(Protocol__FlexranMessage *msg) {
     }
 
     if (reply->cell_config[i]->slice_config) {
-      for (int j = 0; j < reply->cell_config[i]->slice_config->n_dl; ++j) {
-        if (reply->cell_config[i]->slice_config->dl[j]->n_sorting > 0)
-          free(reply->cell_config[i]->slice_config->dl[j]->sorting);
-
-        free(reply->cell_config[i]->slice_config->dl[j]->scheduler_name);
-        free(reply->cell_config[i]->slice_config->dl[j]);
-      }
-
-      free(reply->cell_config[i]->slice_config->dl);
-
-      for (int j = 0; j < reply->cell_config[i]->slice_config->n_ul; ++j) {
-        if (reply->cell_config[i]->slice_config->ul[j]->n_sorting > 0)
-          free(reply->cell_config[i]->slice_config->ul[j]->sorting);
-
-        free(reply->cell_config[i]->slice_config->ul[j]->scheduler_name);
-        free(reply->cell_config[i]->slice_config->ul[j]);
-      }
-
-      free(reply->cell_config[i]->slice_config->ul);
+      /* TODO */
       free(reply->cell_config[i]->slice_config);
     }
 
diff --git a/openair2/ENB_APP/flexran_agent_ran_api.c b/openair2/ENB_APP/flexran_agent_ran_api.c
index 291c4dc7d8352a6ddbf8d13d23f29517b25103bc..cd8b0b8f67dee63e66d5108a86f357e3da927808 100644
--- a/openair2/ENB_APP/flexran_agent_ran_api.c
+++ b/openair2/ENB_APP/flexran_agent_ran_api.c
@@ -3018,142 +3018,44 @@ int flexran_get_ue_dl_slice_id(mid_t mod_id, mid_t ue_id) {
   return 0;
 }
 
-void flexran_set_ue_dl_slice_idx(mid_t mod_id, mid_t ue_id, int slice_idx) {
-  if (!mac_is_present(mod_id)) return;
-}
-
 int flexran_get_ue_ul_slice_id(mid_t mod_id, mid_t ue_id) {
   if (!mac_is_present(mod_id)) return -1;
   return 0;
 }
 
-void flexran_set_ue_ul_slice_idx(mid_t mod_id, mid_t ue_id, int slice_idx) {
-  if (!mac_is_present(mod_id)) return;
-}
-
-int flexran_dl_slice_exists(mid_t mod_id, int slice_idx) {
-  if (!mac_is_present(mod_id)) return -1;
-  return 0;
-}
-
+/* TODO */
 int flexran_create_dl_slice(mid_t mod_id, slice_id_t slice_id) {
   if (!mac_is_present(mod_id)) return -1;
   return -1;
 }
 
-int flexran_find_dl_slice(mid_t mod_id, slice_id_t slice_id) {
-  if (!mac_is_present(mod_id)) return -1;
-  return -1;
-}
-
+/* TODO */
 int flexran_remove_dl_slice(mid_t mod_id, int slice_idx) {
   if (!mac_is_present(mod_id)) return -1;
   return -1;
 }
 
-int flexran_get_num_dl_slices(mid_t mod_id) {
-  if (!mac_is_present(mod_id)) return -1;
-  return 0;
-}
-
-int flexran_get_intraslice_sharing_active(mid_t mod_id) {
-  if (!mac_is_present(mod_id)) return -1;
-  return -1;
-}
-void flexran_set_intraslice_sharing_active(mid_t mod_id, int intraslice_active) {
-  if (!mac_is_present(mod_id)) return;
-}
-
-int flexran_get_interslice_sharing_active(mid_t mod_id) {
-  if (!mac_is_present(mod_id)) return -1;
-  return -1;
-}
-void flexran_set_interslice_sharing_active(mid_t mod_id, int interslice_active) {
-  if (!mac_is_present(mod_id)) return;
-}
-
-slice_id_t flexran_get_dl_slice_id(mid_t mod_id, int slice_idx) {
-  if (!mac_is_present(mod_id)) return -1;
-  return -1;
-}
-void flexran_set_dl_slice_id(mid_t mod_id, int slice_idx, slice_id_t slice_id) {
-  if (!mac_is_present(mod_id)) return;
-}
-
-int flexran_get_dl_slice_percentage(mid_t mod_id, int slice_idx) {
-  if (!mac_is_present(mod_id)) return -1;
-  return -1;
-}
-void flexran_set_dl_slice_percentage(mid_t mod_id, int slice_idx, int percentage) {
-  if (!mac_is_present(mod_id)) return;
-}
-
-int flexran_get_dl_slice_isolation(mid_t mod_id, int slice_idx) {
-  if (!mac_is_present(mod_id)) return -1;
-  return -1;
-}
-void flexran_set_dl_slice_isolation(mid_t mod_id, int slice_idx, int is_isolated) {
-  if (!mac_is_present(mod_id)) return;
-}
-
-int flexran_get_dl_slice_priority(mid_t mod_id, int slice_idx) {
-  if (!mac_is_present(mod_id)) return -1;
-  return -1;
-}
-void flexran_set_dl_slice_priority(mid_t mod_id, int slice_idx, int priority) {
-  if (!mac_is_present(mod_id)) return;
-}
-
-int flexran_get_dl_slice_position_low(mid_t mod_id, int slice_idx) {
-  if (!mac_is_present(mod_id)) return -1;
-  return -1;
-}
-void flexran_set_dl_slice_position_low(mid_t mod_id, int slice_idx, int poslow) {
-  if (!mac_is_present(mod_id)) return;
-}
-
-int flexran_get_dl_slice_position_high(mid_t mod_id, int slice_idx) {
+int flexran_find_dl_slice(mid_t mod_id, slice_id_t slice_id) {
   if (!mac_is_present(mod_id)) return -1;
   return -1;
 }
-void flexran_set_dl_slice_position_high(mid_t mod_id, int slice_idx, int poshigh) {
-  if (!mac_is_present(mod_id)) return;
-}
 
-int flexran_get_dl_slice_maxmcs(mid_t mod_id, int slice_idx) {
-  if (!mac_is_present(mod_id)) return -1;
-  return -1;
-}
-void flexran_set_dl_slice_maxmcs(mid_t mod_id, int slice_idx, int maxmcs) {
-  if (!mac_is_present(mod_id)) return;
-}
+//int flexran_get_dl_slice(mid_t mod_id, int slice_idx, Protocol__FlexSlice *s) {
+//}
 
-int flexran_get_dl_slice_sorting(mid_t mod_id, int slice_idx, Protocol__FlexDlSorting **sorting_list) {
+int flexran_get_num_dl_slices(mid_t mod_id) {
   if (!mac_is_present(mod_id)) return -1;
-  return -1;
-}
-void flexran_set_dl_slice_sorting(mid_t mod_id, int slice_idx, Protocol__FlexDlSorting *sorting_list, int n) {
-  if (!mac_is_present(mod_id)) return;
+  return 0;
 }
 
-Protocol__FlexDlAccountingPolicy flexran_get_dl_slice_accounting_policy(mid_t mod_id, int slice_idx) {
-  if (!mac_is_present(mod_id)) return PROTOCOL__FLEX_DL_ACCOUNTING_POLICY__POL_FAIR;
-  return PROTOCOL__FLEX_DL_ACCOUNTING_POLICY__POL_FAIR;
-}
-void flexran_set_dl_slice_accounting_policy(mid_t mod_id, int slice_idx, Protocol__FlexDlAccountingPolicy accounting) {
+/* TODO */
+void flexran_create_ul_slice(mid_t mod_id, slice_id_t slice_id) {
   if (!mac_is_present(mod_id)) return;
+  return;
 }
 
-char *flexran_get_dl_slice_scheduler(mid_t mod_id, int slice_idx) {
-  if (!mac_is_present(mod_id)) return NULL;
-  return NULL;
-}
-int flexran_set_dl_slice_scheduler(mid_t mod_id, int slice_idx, char *name) {
-  if (!mac_is_present(mod_id)) return 0;
-  return 0;
-}
-
-int flexran_create_ul_slice(mid_t mod_id, slice_id_t slice_id) {
+/* TODO */
+int flexran_remove_ul_slice(mid_t mod_id, int slice_idx) {
   if (!mac_is_present(mod_id)) return -1;
   return -1;
 }
@@ -3163,62 +3065,14 @@ int flexran_find_ul_slice(mid_t mod_id, slice_id_t slice_id) {
   return -1;
 }
 
-int flexran_remove_ul_slice(mid_t mod_id, int slice_idx) {
-  if (!mac_is_present(mod_id)) return -1;
-  return -1;
-}
+//int flexran_get_ul_slice(mid_t mod_id, int slice_idx, Protocol__FlexSlice *s) {
+//}
 
 int flexran_get_num_ul_slices(mid_t mod_id) {
   if (!mac_is_present(mod_id)) return -1;
   return 0;
 }
 
-int flexran_ul_slice_exists(mid_t mod_id, int slice_idx) {
-  if (!mac_is_present(mod_id)) return -1;
-  return 0;
-}
-
-slice_id_t flexran_get_ul_slice_id(mid_t mod_id, int slice_idx) {
-  if (!mac_is_present(mod_id)) return -1;
-  return -1;
-}
-void flexran_set_ul_slice_id(mid_t mod_id, int slice_idx, slice_id_t slice_id) {
-  if (!mac_is_present(mod_id)) return;
-}
-
-int flexran_get_ul_slice_percentage(mid_t mod_id, int slice_idx) {
-  if (!mac_is_present(mod_id)) return -1;
-  return -1;
-}
-void flexran_set_ul_slice_percentage(mid_t mod_id, int slice_idx, int percentage) {
-  if (!mac_is_present(mod_id)) return;
-}
-
-int flexran_get_ul_slice_first_rb(mid_t mod_id, int slice_idx) {
-  if (!mac_is_present(mod_id)) return -1;
-  return -1;
-}
-
-void flexran_set_ul_slice_first_rb(mid_t mod_id, int slice_idx, int first_rb) {
-  if (!mac_is_present(mod_id)) return;
-}
-
-int flexran_get_ul_slice_maxmcs(mid_t mod_id, int slice_idx) {
-  if (!mac_is_present(mod_id)) return -1;
-  return -1;
-}
-void flexran_set_ul_slice_maxmcs(mid_t mod_id, int slice_idx, int maxmcs) {
-  if (!mac_is_present(mod_id)) return;
-}
-
-char *flexran_get_ul_slice_scheduler(mid_t mod_id, int slice_idx) {
-  if (!mac_is_present(mod_id)) return NULL;
-  return "";
-}
-int flexran_set_ul_slice_scheduler(mid_t mod_id, int slice_idx, char *name) {
-  if (!mac_is_present(mod_id)) return 0;
-  return 0;
-}
 
 /************************** S1AP **************************/
 int flexran_get_s1ap_mme_pending(mid_t mod_id){
diff --git a/openair2/ENB_APP/flexran_agent_ran_api.h b/openair2/ENB_APP/flexran_agent_ran_api.h
index 9d1bfb9d3e8fb568b53ee583a4fdcfe42734ea29..c29ba53c1119360083a084b2379633a745edb13b 100644
--- a/openair2/ENB_APP/flexran_agent_ran_api.h
+++ b/openair2/ENB_APP/flexran_agent_ran_api.h
@@ -659,153 +659,38 @@ uint32_t flexran_get_rrc_enb_ue_s1ap_id(mid_t mod_id, rnti_t rnti);
 
 /* Get the DL slice ID for a UE */
 int flexran_get_ue_dl_slice_id(mid_t mod_id, mid_t ue_id);
-
 /* Set the DL slice index(!) for a UE */
-void flexran_set_ue_dl_slice_idx(mid_t mod_id, mid_t ue_id, int slice_idx);
+//void flexran_set_ue_dl_slice_idx(mid_t mod_id, mid_t ue_id, int slice_idx);
 
 /* Get the UL slice ID for a UE */
 int flexran_get_ue_ul_slice_id(mid_t mod_id, mid_t ue_id);
-
 /* Set the UL slice index(!) for a UE */
-void flexran_set_ue_ul_slice_idx(mid_t mod_id, mid_t ue_id, int slice_idx);
-
-/* Whether intraslice sharing is active, return boolean */
-int flexran_get_intraslice_sharing_active(mid_t mod_id);
-/* Set whether intraslice sharing is active */
-void flexran_set_intraslice_sharing_active(mid_t mod_id, int intraslice_active);
+//void flexran_set_ue_ul_slice_idx(mid_t mod_id, mid_t ue_id, int slice_idx);
 
-/* Whether intraslice sharing is active, return boolean */
-int flexran_get_interslice_sharing_active(mid_t mod_id);
-/* Set whether intraslice sharing is active */
-void flexran_set_interslice_sharing_active(mid_t mod_id, int interslice_active);
+/* Create slice in DL, returns the new slice index */
+//int flexran_create_dl_slice(mid_t mod_id, slice_id_t slice_id);
+/* Remove slice in DL, returns new number of slices or -1 on error */
+//int flexran_remove_dl_slice(mid_t mod_id, int slice_idx);
 
+/* Finds slice in DL with given slice_id and returns slice index */
+int flexran_find_dl_slice(mid_t mod_id, slice_id_t slice_id);
+/* Return the parameters of slice at index slice_idx */
+//void flexran_get_dl_slice(mid_t mod_id, int slice_idx, Protocol__FlexSlice *s);
 /* Get the number of slices in DL */
 int flexran_get_num_dl_slices(mid_t mod_id);
 
-/* Query slice existence in DL. Return is boolean value */
-int flexran_dl_slice_exists(mid_t mod_id, int slice_idx);
+/* Create slice in UL, returns the new slice index */
+//int flexran_create_ul_slice(mid_t mod_id, slice_id_t slice_id);
+/* Remove slice in UL */
+//int flexran_remove_ul_slice(mid_t mod_id, int slice_idx);
 
-/* Create slice in DL, returns the new slice index */
-int flexran_create_dl_slice(mid_t mod_id, slice_id_t slice_id);
 /* Finds slice in DL with given slice_id and returns slice index */
-int flexran_find_dl_slice(mid_t mod_id, slice_id_t slice_id);
-/* Remove slice in DL, returns new number of slices or -1 on error */
-int flexran_remove_dl_slice(mid_t mod_id, int slice_idx);
-
-/* Get the ID of a slice in DL */
-slice_id_t flexran_get_dl_slice_id(mid_t mod_id, int slice_idx);
-/* Set the ID of a slice in DL */
-void flexran_set_dl_slice_id(mid_t mod_id, int slice_idx, slice_id_t slice_id);
-
-/* Get the RB share a slice in DL, value 0-100 */
-int flexran_get_dl_slice_percentage(mid_t mod_id, int slice_idx);
-/* Set the RB share a slice in DL, value 0-100 */
-void flexran_set_dl_slice_percentage(mid_t mod_id, int slice_idx, int percentage);
-
-/* Whether a slice in DL is isolated */
-int flexran_get_dl_slice_isolation(mid_t mod_id, int slice_idx);
-/* Set whether a slice in DL is isolated */
-void flexran_set_dl_slice_isolation(mid_t mod_id, int slice_idx, int is_isolated);
-
-/* Get the priority of a slice in DL */
-int flexran_get_dl_slice_priority(mid_t mod_id, int slice_idx);
-/* Get the priority of a slice in DL */
-void flexran_set_dl_slice_priority(mid_t mod_id, int slice_idx, int priority);
-
-/* Get the lower end of the frequency range for the slice positioning in DL */
-int flexran_get_dl_slice_position_low(mid_t mod_id, int slice_idx);
-/* Set the lower end of the frequency range for the slice positioning in DL */
-void flexran_set_dl_slice_position_low(mid_t mod_id, int slice_idx, int poslow);
-
-/* Get the higher end of the frequency range for the slice positioning in DL */
-int flexran_get_dl_slice_position_high(mid_t mod_id, int slice_idx);
-/* Set the higher end of the frequency range for the slice positioning in DL */
-void flexran_set_dl_slice_position_high(mid_t mod_id, int slice_idx, int poshigh);
-
-/* Get the maximum MCS for slice in DL */
-int flexran_get_dl_slice_maxmcs(mid_t mod_id, int slice_idx);
-/* Set the maximum MCS for slice in DL */
-void flexran_set_dl_slice_maxmcs(mid_t mod_id, int slice_idx, int maxmcs);
-
-/* Get the sorting order of a slice in DL, return value is number of elements
- * in sorting_list */
-int flexran_get_dl_slice_sorting(mid_t mod_id, int slice_idx, Protocol__FlexDlSorting **sorting_list);
-/* Set the sorting order of a slice in DL */
-void flexran_set_dl_slice_sorting(mid_t mod_id, int slice_idx, Protocol__FlexDlSorting *sorting_list, int n);
-
-/* Get the accounting policy for a slice in DL */
-Protocol__FlexDlAccountingPolicy flexran_get_dl_slice_accounting_policy(mid_t mod_id, int slice_idx);
-/* Set the accounting policy for a slice in DL */
-void flexran_set_dl_slice_accounting_policy(mid_t mod_id, int slice_idx, Protocol__FlexDlAccountingPolicy accounting);
-
-/* Get the scheduler name for a slice in DL */
-char *flexran_get_dl_slice_scheduler(mid_t mod_id, int slice_idx);
-/* Set the scheduler name for a slice in DL */
-int flexran_set_dl_slice_scheduler(mid_t mod_id, int slice_idx, char *name);
-
+int flexran_find_ul_slice(mid_t mod_id, slice_id_t slice_id);
+/* Return the parameters of slice at index slice_idx */
+//void flexran_get_ul_slice(mid_t mod_id, int slice_idx, Protocol__FlexSlice *s);
 /* Get the number of slices in UL */
 int flexran_get_num_ul_slices(mid_t mod_id);
 
-/* Query slice existence in UL. Return is boolean value */
-int flexran_ul_slice_exists(mid_t mod_id, int slice_idx);
-
-/* Create slice in UL, returns the new slice index */
-int flexran_create_ul_slice(mid_t mod_id, slice_id_t slice_id);
-/* Finds slice in UL with given slice_id and returns slice index */
-int flexran_find_ul_slice(mid_t mod_id, slice_id_t slice_id);
-/* Remove slice in UL */
-int flexran_remove_ul_slice(mid_t mod_id, int slice_idx);
-
-/* Get the ID of a slice in UL */
-slice_id_t flexran_get_ul_slice_id(mid_t mod_id, int slice_idx);
-/* Set the ID of a slice in UL */
-void flexran_set_ul_slice_id(mid_t mod_id, int slice_idx, slice_id_t slice_id);
-
-/* Get the RB share a slice in UL, value 0-100 */
-int flexran_get_ul_slice_percentage(mid_t mod_id, int slice_idx);
-/* Set the RB share a slice in UL, value 0-100 */
-void flexran_set_ul_slice_percentage(mid_t mod_id, int slice_idx, int percentage);
-
-/* TODO Whether a slice in UL is isolated */
-/*int flexran_get_ul_slice_isolation(mid_t mod_id, int slice_idx);*/
-/* TODO Set whether a slice in UL is isolated */
-/*void flexran_set_ul_slice_isolation(mid_t mod_id, int slice_idx, int is_isolated);*/
-
-/* TODO Get the priority of a slice in UL */
-/*int flexran_get_ul_slice_priority(mid_t mod_id, int slice_idx);*/
-/* TODO Set the priority of a slice in UL */
-/*void flexran_set_ul_slice_priority(mid_t mod_id, int slice_idx, int priority);*/
-
-/* Get the first RB for allocation in a slice in UL */
-int flexran_get_ul_slice_first_rb(mid_t mod_id, int slice_idx);
-/* Set the first RB for allocation in a slice in UL */
-void flexran_set_ul_slice_first_rb(mid_t mod_id, int slice_idx, int first_rb);
-
-/* TODO Get the number of RB for the allocation in a slice in UL */
-/*int flexran_get_ul_slice_length_rb(mid_t mod_id, int slice_idx);*/
-/* TODO Set the of number of RB for the allocation in a slice in UL */
-/*void flexran_set_ul_slice_length_rb(mid_t mod_id, int slice_idx, int poshigh);*/
-
-/* Get the maximum MCS for slice in UL */
-int flexran_get_ul_slice_maxmcs(mid_t mod_id, int slice_idx);
-/* Set the maximum MCS for slice in UL */
-void flexran_set_ul_slice_maxmcs(mid_t mod_id, int slice_idx, int maxmcs);
-
-/* TODO Get the sorting order of a slice in UL, return value is number of elements
- * in sorting_list */
-/*int flexran_get_ul_slice_sorting(mid_t mod_id, int slice_idx, Protocol__FlexUlSorting **sorting_list);*/
-/* TODO Set the sorting order of a slice in UL */
-/*void flexran_set_ul_slice_sorting(mid_t mod_id, int slice_idx, Protocol__FlexUlSorting *sorting_list, int n);*/
-
-/* TODO Get the accounting policy for a slice in UL */
-/*Protocol__UlAccountingPolicy flexran_get_ul_slice_accounting_policy(mid_t mod_id, int slice_idx);*/
-/* TODO Set the accounting policy for a slice in UL */
-/*void flexran_get_ul_slice_accounting_policy(mid_t mod_id, int slice_idx, Protocol__UlAccountingPolicy accountin);*/
-
-/* Get the scheduler name for a slice in UL */
-char *flexran_get_ul_slice_scheduler(mid_t mod_id, int slice_idx);
-/* Set the scheduler name for a slice in UL */
-int flexran_set_ul_slice_scheduler(mid_t mod_id, int slice_idx, char *name);
 
 /************************** S1AP **************************/
 /* Get the number of MMEs to be connected */