diff --git a/src/profiler/configuration.c b/src/profiler/configuration.c
index 7fbf68c0ca..b427ed453c 100644
--- a/src/profiler/configuration.c
+++ b/src/profiler/configuration.c
@@ -1,5 +1,6 @@
 #include "moar.h"
 
+#define CONFPROG_UNUSED_ENTRYPOINT 1
 
 #define OUTPUT_LOTS_OF_JUNK 1
 
@@ -386,6 +387,7 @@ void MVM_confprog_install(MVMThreadContext *tc, MVMObject *bytecode, MVMObject *
     MVMuint64 bytecode_size;
     MVMuint8 *array_contents;
     MVMConfigurationProgram *confprog;
+    MVMint16 entrypoint_array[MVM_PROGRAM_ENTRYPOINT_COUNT];
 
     CHECK_CONC(bytecode, VMArray, "the bytecode");
     CHECK_CONC(string_array, VMArray, "the string heap");
@@ -429,25 +431,45 @@ void MVM_confprog_install(MVMThreadContext *tc, MVMObject *bytecode, MVMObject *
     {
         MVMObject *arr = entrypoints;
         MVMArrayREPRData *reprdata = (MVMArrayREPRData *)STABLE(arr)->REPR_data;
+        MVMuint64 index;
+        MVMuint64 count;
 
         if (reprdata->slot_type != MVM_ARRAY_I64) {
             MVM_exception_throw_adhoc(tc, "installconfprog requires the entrypoints array to be a native array of 64-bit integers (got a %s)",
                     MVM_6model_get_debug_name(tc, bytecode));
         }
+
+        count = MVM_repr_elems(tc, arr);
+
+        memset(entrypoint_array, 0, sizeof(entrypoint_array));
+
+        junkprint(stderr, "copying over %d entrypoints\n", count);
+
+        for (index = 0; index < count && index < MVM_PROGRAM_ENTRYPOINT_COUNT; index++) {
+            entrypoint_array[index] = MVM_repr_at_pos_i(tc, arr, index);
+            junkprint(stderr, "  - %d == %d\n", index, entrypoint_array[index]);
+        }
     }
 
     confprog = MVM_calloc(sizeof(MVMConfigurationProgram), 1);
 
+    fprintf(stderr, "copying %d (%x) bytecode entries\n", bytecode_size, bytecode_size);
     confprog->bytecode = MVM_malloc(bytecode_size);
     memcpy(confprog->bytecode, array_contents, bytecode_size);
 
+    memcpy(confprog->entrypoints, entrypoint_array, sizeof(entrypoint_array));
+
     confprog->bytecode_length = bytecode_size;
 
     confprog->string_heap = string_array;
 
     MVM_confprog_validate(tc, confprog);
 
-    MVM_confprog_run(tc, confprog, tc->instance->VMNull, 0);
+    tc->instance->confprog = confprog;
+}
+
+MVMuint8 MVM_confprog_has_entrypoint(MVMThreadContext *tc, MVMuint8 entrypoint) {
+    return tc->instance->confprog && entrypoint < MVM_PROGRAM_ENTRYPOINT_COUNT && tc->instance->confprog->entrypoints[entrypoint] != CONFPROG_UNUSED_ENTRYPOINT;
 }
 
 /* Stolen from interp.c */
@@ -462,10 +484,21 @@ void MVM_confprog_install(MVMThreadContext *tc, MVMObject *bytecode, MVMObject *
 MVMint64 MVM_confprog_run(MVMThreadContext *tc, void *subject, MVMuint8 entrypoint, MVMint64 initial_feature_value) {
     MVMConfigurationProgram *prog = tc->instance->confprog;
     MVMuint8 *cur_op;
+    MVMuint8 *last_op;
+    MVMint64 result;
+
+    MVMuint8 *bytecode_start;
 
     CPRegister *reg_base = MVM_calloc(prog->reg_count + 1, sizeof(CPRegister));
 
-    cur_op = prog->bytecode;
+    reg_base[REGISTER_FEATURE_TOGGLE].i64 = initial_feature_value;
+
+    bytecode_start = prog->bytecode;
+    cur_op = bytecode_start + prog->entrypoints[entrypoint];
+    last_op = bytecode_start + prog->bytecode_length;
+
+    junkprint(stderr, "running confprog for entrypoint %d (at position %d)\n", entrypoint, prog->entrypoints[entrypoint]);
+    junkprint(stderr, "confprog is 0x%x (%d) bytes big", last_op - bytecode_start, last_op - bytecode_start);
 
     runloop: {
         MVMuint16 ins = *((MVMuint16 *)cur_op);
@@ -487,6 +520,10 @@ MVMint64 MVM_confprog_run(MVMThreadContext *tc, void *subject, MVMuint8 entrypoi
                 junkprint(stderr, "const_i64 %d\n", MVM_BC_get_I64(cur_op, 2));
                 cur_op += 10;
                 goto NEXT;
+            OP(const_n64):
+                GET_REG(cur_op, 0).n64 = MVM_BC_get_N64(cur_op, 2);
+                cur_op += 10;
+                goto NEXT;
             OP(const_i64_16):
                 GET_REG(cur_op, 0).i64 = GET_I16(cur_op, 2);
                 junkprint(stderr, "const_i64_16 %d into %d\n", GET_I16(cur_op, 2), GET_UI16(cur_op, 0));
@@ -583,6 +620,27 @@ MVMint64 MVM_confprog_run(MVMThreadContext *tc, void *subject, MVMuint8 entrypoi
                 MVM_coerce_smart_stringify(tc, obj, res);
                 goto NEXT;
             }
+            OP(gt_n):
+                GET_REG(cur_op, 0).i64 = GET_REG(cur_op, 2).n64 >  GET_REG(cur_op, 4).n64;
+                cur_op += 6;
+                goto NEXT;
+            OP(rand_n):
+                GET_REG(cur_op, 0).n64 = MVM_proc_rand_n(tc);
+                cur_op += 2;
+                goto NEXT;
+            OP(goto):
+                cur_op = bytecode_start + GET_UI32(cur_op, 0);
+                goto NEXT;
+            OP(if_i):
+                if (GET_REG(cur_op, 0).i64)
+                    cur_op = bytecode_start + GET_UI32(cur_op, 2);
+                else
+                    cur_op += 6;
+                goto NEXT;
+            OP(exit): {
+                MVMint64 exit_code = GET_REG(cur_op, 0).i64;
+                goto finish_main_loop;
+            }
             default:
                 fprintf(stderr, "operation %s (%d, 0x%x) NYI\n", MVM_op_get_op(ins)->name, ins, ins);
                 goto finish_main_loop;
diff --git a/src/profiler/configuration.h b/src/profiler/configuration.h
index b9b0c8c009..a95b6130b0 100644
--- a/src/profiler/configuration.h
+++ b/src/profiler/configuration.h
@@ -2,8 +2,15 @@
 #define MVM_PROGRAM_ENTRYPOINT_PROFILER_DYNAMIC 1
 #define MVM_PROGRAM_ENTRYPOINT_SPESH 2
 #define MVM_PROGRAM_ENTRYPOINT_JIT 3
+#define MVM_PROGRAM_ENTRYPOINT_HEAPSNAPSHOT 4
 
-#define MVM_PROGRAM_ENTRYPOINT_COUNT 4
+#define MVM_PROGRAM_ENTRYPOINT_COUNT 5
+
+#define MVM_CONFPROG_SF_RESULT_TO_BE_DETERMINED 0
+#define MVM_CONFPROG_SF_RESULT_NEVER 1
+#define MVM_CONFPROG_SF_RESULT_DYNAMIC_SUGGEST_NO 2
+#define MVM_CONFPROG_SF_RESULT_DYNAMIC_SUGGEST_YES 3
+#define MVM_CONFPROG_SF_RESULT_ALWAYS 4
 
 struct MVMConfigurationProgramEntryPoint {
     MVMuint32 offset;
@@ -22,6 +29,7 @@ struct MVMConfigurationProgram {
     MVMint16 entrypoints[MVM_PROGRAM_ENTRYPOINT_COUNT];
 };
 
+MVMuint8 MVM_confprog_has_entrypoint(MVMThreadContext *tc, MVMuint8 entrypoint);
 MVMint64 MVM_confprog_run(MVMThreadContext *tc, void *subject, MVMuint8 entrypoint, MVMint64 initial_feature_value);
 void MVM_confprog_mark(MVMThreadContext *tc, MVMGCWorklist *worklist, MVMHeapSnapshotState *snapshot);
 void MVM_confprog_install(MVMThreadContext *tc, MVMObject *bytecode, MVMObject *string_array, MVMObject *entrypoints);
diff --git a/src/profiler/heapsnapshot.c b/src/profiler/heapsnapshot.c
index b301181c35..ee1bee4d0c 100644
--- a/src/profiler/heapsnapshot.c
+++ b/src/profiler/heapsnapshot.c
@@ -925,14 +925,27 @@ void finish_collection_to_filehandle(MVMThreadContext *tc, MVMHeapSnapshotCollec
 void MVM_profile_heap_take_snapshot(MVMThreadContext *tc) {
     if (MVM_profile_heap_profiling(tc)) {
         MVMHeapSnapshotCollection *col = tc->instance->heap_snapshots;
-        col->snapshot = MVM_calloc(1, sizeof(MVMHeapSnapshot));
+        MVMint64 do_heapsnapshot = 1;
 
-        record_snapshot(tc, col, col->snapshot);
+        fprintf(stderr, "checking for confprog on entrypoint %d\n", MVM_PROGRAM_ENTRYPOINT_HEAPSNAPSHOT);
+        if (MVM_confprog_has_entrypoint(tc, MVM_PROGRAM_ENTRYPOINT_HEAPSNAPSHOT)) {
+            do_heapsnapshot = MVM_confprog_run(tc, NULL, MVM_PROGRAM_ENTRYPOINT_HEAPSNAPSHOT, do_heapsnapshot);
+        }
+
+        if (do_heapsnapshot) {
+            col->snapshot = MVM_calloc(1, sizeof(MVMHeapSnapshot));
+
+            fprintf(stderr, "doing snapshot\n");
+            record_snapshot(tc, col, col->snapshot);
 
-        snapshot_to_filehandle(tc, col);
-        fflush(col->fh);
+            snapshot_to_filehandle(tc, col);
+            fflush(col->fh);
 
-        destroy_current_heap_snapshot(tc);
+            destroy_current_heap_snapshot(tc);
+        }
+        else {
+            fprintf(stderr, "not doing snapshot\n");
+        }
         col->snapshot_idx++;
     }
 }
diff --git a/tools/compile_confprog.p6 b/tools/compile_confprog.p6
index 563f9c3507..f22eceaa82 100644
--- a/tools/compile_confprog.p6
+++ b/tools/compile_confprog.p6
@@ -81,6 +81,7 @@ grammar ConfProg {
             | 'profiler_dynamic'
             | 'spesh'
             | 'jit'
+            | 'heapsnapshot'
         ] \s*
         ":"
     }
@@ -147,6 +148,10 @@ grammar ConfProg {
         <prefixop> '(' \s* <expression> \s* ')'
     }
 
+    regex one_expression:<functioncall> {
+        <ident> '(' (<one_expression> | <named>)* %% [\s* ',' \s*] ')'
+    }
+
     proto regex postfixish { * }
     regex postfixish:<attribute> {
         '.' <ident>
@@ -235,6 +240,8 @@ my %prefix-to-op = <
 >;
 
 class ConfProgActions {
+    has %.labels;
+
     method prefixop($/) { make $/.Str }
     method compop($/)   { say $/.Str; make %op-to-op{$/.Str} }
 
@@ -294,6 +301,34 @@ class ConfProgActions {
         make $result;
     }
 
+    method one_expression:<functioncall>($/) {
+        use Data::Dump::Tree::ExtraRoles;
+
+        my @positionals;
+        my @nameds;
+        my $matchddt = Data::Dump::Tree.new;
+        $matchddt does DDTR::MatchDetails;
+        $matchddt.dump: $/;
+
+        for @0 {
+            with .<one_expression> {
+                @positionals.push: .ast;
+            }
+            orwith .<named> {
+                die "named arguments in functioncall NYI";
+                @nameds.push: .ast;
+            }
+        }
+
+        my $result = Op.new(
+            op => "call",
+            children => [
+                flat $<ident>.Str,
+                @positionals, @nameds
+            ]);
+        make $result;
+    }
+
     method statement:<entrypoint>($/) {
         make Label.new(
             name => $<entrypoint>.Str,
@@ -301,10 +336,17 @@ class ConfProgActions {
         );
     }
     method statement:<label>($/) {
-        make Label.new(
-            name => $<entrypoint>.Str,
+        my $label = Label.new(
+            name => $<ident>.Str,
             type => "user"
         );
+        with %.labels{$<ident>.Str} {
+            die "duplicate definition of label $<ident>.Str()";
+        }
+        else {
+            $_ = $label;
+        }
+        make $label;
     }
 
     method statement:<var_update>($/) {
@@ -374,6 +416,7 @@ my %builtins = %(
 my %targets = %(
     profile => CPInt,
     log => CPString,
+    snapshot => CPInt,
 );
 
 use MASTOps:from<NQP>;
@@ -385,13 +428,18 @@ my %entrypoint-indices = <
     profiler_dynamic
     spesh
     jit
+    heapsnapshot
 >.antipairs;
 
 my $*MAST_FRAME = class {
-    has uint8 @.bytecode;
+    has @.bytecode is buf8;
     has str @.strings;
     has @.entrypoints is default(1);
 
+    has %.labelrefs{Any};
+
+    has $.dump-position = 0;
+
     method add-string(str $str) {
         if @!strings.grep($str, :k) {
             return $_[0]
@@ -415,13 +463,49 @@ my $*MAST_FRAME = class {
         }
     }
     method compile_label($bytecode, $label) {
-        die "label support NYI";
+        with $label.position {
+            die "labels must not appear before their declaration, sorry!"
+        }
+        %.labelrefs{$label}.push: $bytecode.elems;
+        $bytecode.write-uint32($bytecode.elems, 0xbbaabbaabbaabba);
+    }
+
+    method finish-labels() {
+        for %.labelrefs {
+            say "key and value:";
+            say .key.perl();
+            say .value.perl();
+            for .value.list -> $fixup-pos {
+                @!bytecode.write-uint32($fixup-pos, .key.position);
+            }
+        }
+    }
+
+    method dump-new-stuff() {
+        for @!bytecode.skip($!dump-position) -> $a, $b {
+            state $pos = 0;
+            my int $cur-pos = $!dump-position + $pos;
+            $pos += 2;
+
+            my int $sixteenbitval = $b * 256 + $a;
+
+            if $pos == 2 {
+                my Mu $names := MAST::Ops.WHO<@names>;
+                if $sixteenbitval < nqp::elems($names) {
+                    say nqp::atpos_s($names, $sixteenbitval);
+                }
+            }
+
+            say "$cur-pos.fmt("0x% 4x") $sixteenbitval.fmt("%04x") ($sixteenbitval.fmt("%05d"))  -- $a.fmt("%02x") $b.fmt("%02x") / $a.fmt("%03d") $b.fmt("%03d")";
+        }
+        $!dump-position = +@!bytecode;
+        say "";
     }
 }.new;
 
 my $parseresult = ConfProg.parse($testprog, actions => ConfProgActions.new);
 
-"$_[1].perl()".say && $_[0].&ddt && "".say for $parseresult.ast Z $parseresult<statement>.list>>.Str;
+#"$_[1].perl()".say && $_[0].&ddt && "".say for $parseresult.ast Z $parseresult<statement>.list>>.Str;
 
 # type derivation step
 
@@ -504,6 +588,18 @@ multi sub unify_type(Op $node) {
                         ?? CPInt
                         !! die "what"));
         }
+        when "call" {
+            # Go by first child, it ought to be a string with the function name.
+            my $funcname = $node.children[0];
+            given $funcname {
+                when "choice" {
+                    $node.type = CPInt;
+                }
+                default {
+                    die "function call to $funcname.perl() NYI, typo'd, or something else is wrong";
+                }
+            }
+        }
         default {
             warn "unhandled node op $node.op() in unify_type for an Op";
             return Any;
@@ -550,6 +646,7 @@ enum RegisterType <
     RegInteger
     RegString
     RegCString
+    RegNum
 >;
 
 my %CPTypeToRegType := :{
@@ -635,6 +732,8 @@ multi sub compile_coerce($node, $type, :$target!) {
     }
 }
 
+my $current-entrypoint;
+
 multi sub compile_node(SVal $val, :$target!) {
     note "const_s into $target";
     %op-gen<const_s>($target, $val.value);
@@ -657,12 +756,62 @@ multi sub compile_node(Var $var, :$target) {
         }
     }
     elsif $var.scope eq "my" {
-
+        die "user-specified variables NYI"
     }
     else {
         die "unexpected variable scope $var.scope()";
     }
 }
+
+my int $dynamic_label_idx = 1;
+
+sub compile_call(Op $op, :$target) {
+    my $funcname = $op.children[0].Str;
+    given $funcname {
+        when "choice" {
+            say "";
+            say "here is the choice function!";
+            say "";
+            my $value = $*REGALLOC.fresh(RegNum);
+            %op-gen<rand_n>($value);
+        $*MAST_FRAME.dump-new-stuff();
+
+            my $comparison-value = $*REGALLOC.fresh(RegNum);
+            my $comparison-result = $*REGALLOC.fresh(RegInteger);
+
+            my num $step = 1e0 / ($op.children.elems - 1);
+
+            my @individual-labels = Label.new(name => "choice-" ~ $dynamic_label_idx++, type => "internal") xx ($op.children.elems - 2);
+            my $end-label = Label.new(name => "choice-exit-" ~ $dynamic_label_idx++, type => "internal");
+            @individual-labels.push: $end-label;
+
+            my $current-comparison-literal = $step;
+
+            ddt $op;
+
+            for $op.children<>[1..*].list Z @individual-labels {
+                say "choice loop: $_.perl()";
+                say "$_[0].perl()";
+                say "$_[1].perl()";
+                %op-gen<const_n64>($comparison-value, $current-comparison-literal);
+        $*MAST_FRAME.dump-new-stuff();
+                %op-gen<gt_n>($comparison-result, $value, $comparison-value);
+        $*MAST_FRAME.dump-new-stuff();
+                %op-gen<if_i>($comparison-result, .[1]);
+        $*MAST_FRAME.dump-new-stuff();
+                compile_node(.[0], :$target);
+                %op-gen<goto>($end-label);
+        $*MAST_FRAME.dump-new-stuff();
+                compile_node(.[1]);
+            }
+            compile_node($end-label);
+        }
+        default {
+            die "Cannot compile call of function $funcname yet"
+        }
+    }
+}
+
 multi sub compile_node(Op $op, :$target) {
     note "Op $op.op() into $($target // "-")";
     given $op.op {
@@ -677,6 +826,10 @@ multi sub compile_node(Op $op, :$target) {
                 if $lhs.name eq "log" {
                     %op-gen<say>($rhstarget);
                 }
+                elsif $lhs.name eq "snapshot" | "profile" {
+                    note "making a set op into FEATURE_TOGGLE from $rhstarget";
+                    %op-gen<set>(FEATURE_TOGGLE, $rhstarget);
+                }
                 else {
                     die "builtin variable $lhs.name() NYI";
                 }
@@ -750,6 +903,10 @@ multi sub compile_node(Op $op, :$target) {
             $*REGALLOC.release($leftreg);
             $*REGALLOC.release($rightreg);
         }
+        when "call" {
+            compile_call($op, :$target) with $target;
+            compile_call($op) without $target;
+        }
         default {
             die "cannot compile $op.op() yet";
         }
@@ -757,11 +914,17 @@ multi sub compile_node(Op $op, :$target) {
 }
 multi compile_node(Label $label) {
     given $label.type {
-        when "user" {
-            die "user-specified labels NYI";
+        when "user" | "internal" {
+            say "compiling label node and setting position:";
+            $label.position = $*MAST_FRAME.bytecode.elems;
+            say "    $label.position.perl()";
         }
         when "entrypoint" {
+            with $current-entrypoint {
+                %op-gen<exit>(0);
+            }
             $label.position = $*MAST_FRAME.add-entrypoint($label.name);
+            $current-entrypoint = $label.name;
             say "added entrypoint at position $label.position()";
         }
     }
@@ -772,6 +935,7 @@ for $parseresult.ast {
         compile_node($_);
     }
 }
+$*MAST_FRAME.finish-labels();
 
 .say for $*MAST_FRAME.strings.pairs;
 
@@ -782,7 +946,9 @@ dd $*MAST_FRAME.bytecode;
 
 say $*MAST_FRAME.entrypoints;
 
-my int @entrypoints;
+say $*MAST_FRAME.entrypoints.perl;
+
+my int @entrypoints = $*MAST_FRAME.entrypoints >>//>> 1;
 
 sub run-the-program() {
     use nqp;