| #include <stdio.h> |
| #include "libgccjit.h" |
| #include "harness.h" |
| |
| /* This testcase checks that gcc_jit_context_new_constructor() works |
| with locals. Tests that constructors can be used as return |
| values or function call values. Test that constructors can have side |
| effects and be assigned to locals. |
| */ |
| |
| void |
| create_code (gcc_jit_context *ctxt, void *user_data) |
| { |
| gcc_jit_type *int_type = gcc_jit_context_get_type (ctxt, |
| GCC_JIT_TYPE_INT); |
| gcc_jit_type *pint_type = gcc_jit_type_get_pointer (int_type); |
| gcc_jit_type *double_type = gcc_jit_context_get_type (ctxt, |
| GCC_JIT_TYPE_DOUBLE); |
| gcc_jit_type *float_type = gcc_jit_context_get_type (ctxt, |
| GCC_JIT_TYPE_FLOAT); |
| gcc_jit_type *bool_type = gcc_jit_context_get_type (ctxt, |
| GCC_JIT_TYPE_BOOL); |
| gcc_jit_type *char_type = gcc_jit_context_get_type (ctxt, |
| GCC_JIT_TYPE_CHAR); |
| gcc_jit_type *size_type = gcc_jit_context_get_type (ctxt, |
| GCC_JIT_TYPE_SIZE_T); |
| gcc_jit_type *voidptr_type = gcc_jit_context_get_type (ctxt, |
| GCC_JIT_TYPE_VOID_PTR); |
| gcc_jit_type *void_type = gcc_jit_context_get_type (ctxt, |
| GCC_JIT_TYPE_VOID); |
| |
| /* Make a struct: struct fi { float f; int i;} */ |
| gcc_jit_field *fi_f = gcc_jit_context_new_field (ctxt, |
| 0, |
| float_type, |
| "f"); |
| gcc_jit_field *fi_i = gcc_jit_context_new_field (ctxt, |
| 0, |
| int_type, |
| "i"); |
| gcc_jit_field *fields[] = {fi_f, fi_i}; |
| |
| gcc_jit_type *struct_fi_type = |
| gcc_jit_struct_as_type ( |
| gcc_jit_context_new_struct_type (ctxt, |
| 0, |
| "fi", |
| 2, |
| fields)); |
| |
| /* Make a struct: |
| |
| struct bar { |
| int ii; |
| int arr[50]; |
| float ff; |
| char cc; |
| } |
| */ |
| gcc_jit_field *bar_ff = gcc_jit_context_new_field (ctxt, |
| 0, |
| float_type, |
| "ff"); |
| gcc_jit_field *bar_ii = gcc_jit_context_new_field (ctxt, |
| 0, |
| int_type, |
| "ii"); |
| gcc_jit_field *bar_cc = gcc_jit_context_new_field (ctxt, |
| 0, |
| char_type, |
| "cc"); |
| gcc_jit_type *int50arr_type = |
| gcc_jit_context_new_array_type (ctxt, |
| 0, |
| int_type, |
| 50); |
| gcc_jit_field *bar_fi = gcc_jit_context_new_field (ctxt, |
| 0, |
| int50arr_type, |
| "arr"); |
| gcc_jit_field *fields2[] = {bar_ff, bar_fi, bar_ii, bar_cc}; |
| |
| gcc_jit_type *struct_bar_type = |
| gcc_jit_struct_as_type ( |
| gcc_jit_context_new_struct_type (ctxt, |
| 0, |
| "bar", |
| 4, |
| fields2)); |
| |
| /* Make an union: |
| |
| union ubar { |
| float ff; |
| int ii; |
| }; |
| */ |
| gcc_jit_field *ubar_ff = gcc_jit_context_new_field (ctxt, |
| 0, |
| float_type, |
| "ff"); |
| gcc_jit_field *ubar_ii = gcc_jit_context_new_field (ctxt, |
| 0, |
| int_type, |
| "ii"); |
| gcc_jit_field *fields3[] = {ubar_ff, ubar_ii}; |
| gcc_jit_type *ubar = gcc_jit_context_new_union_type (ctxt, |
| 0, |
| "ubar", |
| 2, |
| fields3); |
| |
| (void) ubar; |
| (void) struct_bar_type; |
| (void) struct_fi_type; |
| (void) bool_type; |
| (void) double_type; |
| (void) pint_type; |
| (void) voidptr_type; |
| (void) size_type; |
| |
| gcc_jit_function *fn_int_3; |
| { /* int foo () { int local = 3; return local;} */ |
| fn_int_3 = |
| gcc_jit_context_new_function (ctxt, |
| 0, |
| GCC_JIT_FUNCTION_EXPORTED, |
| int_type, |
| "fn_int_3", |
| 0, |
| 0, |
| 0); |
| gcc_jit_block *block = gcc_jit_function_new_block (fn_int_3, "start"); |
| gcc_jit_lvalue *local = gcc_jit_function_new_local (fn_int_3, |
| 0, |
| int_type, |
| "local"); |
| gcc_jit_rvalue *rval = gcc_jit_context_new_rvalue_from_int ( |
| ctxt, int_type, 3); |
| |
| gcc_jit_block_add_assignment (block, 0, local, rval); |
| |
| gcc_jit_block_end_with_return (block, |
| 0, |
| gcc_jit_lvalue_as_rvalue(local)); |
| } |
| { /* struct fi foo() { return (struct fi){1,2};} */ |
| gcc_jit_function *fn = |
| gcc_jit_context_new_function (ctxt, |
| 0, |
| GCC_JIT_FUNCTION_EXPORTED, |
| struct_fi_type, |
| "fn_fi_1_2", |
| 0, |
| 0, |
| 0); |
| gcc_jit_block *block = gcc_jit_function_new_block (fn, "start"); |
| |
| gcc_jit_rvalue *rval_f1 = gcc_jit_context_new_rvalue_from_int ( |
| ctxt, float_type, 1); |
| gcc_jit_rvalue *rval_i2 = gcc_jit_context_new_rvalue_from_int ( |
| ctxt, int_type, 2); |
| |
| gcc_jit_rvalue *vals[] = { rval_f1, rval_i2}; |
| gcc_jit_field *fields[] = {fi_f, fi_i}; |
| |
| gcc_jit_rvalue *ctor = gcc_jit_context_new_struct_constructor |
| (ctxt, 0, |
| struct_fi_type, |
| 2, |
| fields, |
| vals); |
| |
| gcc_jit_block_end_with_return (block, |
| 0, |
| ctor); |
| } |
| { /* |
| struct fi foo() |
| { |
| struct fi local = {1,2}; |
| local = (struct fi){5,6}; |
| return local; |
| } |
| */ |
| gcc_jit_function *fn = |
| gcc_jit_context_new_function (ctxt, |
| 0, |
| GCC_JIT_FUNCTION_EXPORTED, |
| struct_fi_type, |
| "fn_fi_5_6", |
| 0, |
| 0, |
| 0); |
| gcc_jit_lvalue *local = gcc_jit_function_new_local (fn, |
| 0, |
| struct_fi_type, |
| "local"); |
| gcc_jit_block *block = gcc_jit_function_new_block (fn, "start"); |
| |
| { |
| gcc_jit_rvalue *rval_f1 = |
| gcc_jit_context_new_rvalue_from_int (ctxt, float_type, 1); |
| gcc_jit_rvalue *rval_i2 = |
| gcc_jit_context_new_rvalue_from_int (ctxt, int_type, 2); |
| |
| gcc_jit_rvalue *vals[] = { rval_f1, rval_i2}; |
| gcc_jit_field *fields[] = {fi_f, fi_i}; |
| |
| gcc_jit_rvalue *ctor = gcc_jit_context_new_struct_constructor |
| (ctxt, 0, |
| struct_fi_type, |
| 2, |
| fields, |
| vals); |
| gcc_jit_block_add_assignment (block, 0, local, ctor); |
| } |
| { |
| gcc_jit_rvalue *rval_f1 = |
| gcc_jit_context_new_rvalue_from_int (ctxt, float_type, 5); |
| gcc_jit_rvalue *rval_i2 = |
| gcc_jit_context_new_rvalue_from_int (ctxt, int_type, 6); |
| |
| gcc_jit_rvalue *vals[] = { rval_f1, rval_i2}; |
| gcc_jit_field *fields[] = {fi_f, fi_i}; |
| |
| gcc_jit_rvalue *ctor = gcc_jit_context_new_struct_constructor |
| (ctxt, 0, |
| struct_fi_type, |
| 2, |
| fields, |
| vals); |
| gcc_jit_block_add_assignment (block, 0, local, ctor); |
| } |
| |
| gcc_jit_block_end_with_return (block, |
| 0, |
| gcc_jit_lvalue_as_rvalue(local)); |
| } |
| { /* struct fi foo() { struct fi local = {1, fn_int_3()}; |
| return local;} |
| |
| The ctor has a side effect (funccall) */ |
| gcc_jit_function *fn = |
| gcc_jit_context_new_function (ctxt, |
| 0, |
| GCC_JIT_FUNCTION_EXPORTED, |
| struct_fi_type, |
| "fn_fi_1_3", |
| 0, |
| 0, |
| 0); |
| gcc_jit_lvalue *local = gcc_jit_function_new_local (fn, |
| 0, |
| struct_fi_type, |
| "local"); |
| gcc_jit_block *block = gcc_jit_function_new_block (fn, "start"); |
| |
| { |
| gcc_jit_rvalue *rval_f1 = |
| gcc_jit_context_new_rvalue_from_int (ctxt, float_type, 1); |
| gcc_jit_rvalue *rval_i2 = |
| gcc_jit_context_new_call (ctxt, 0, fn_int_3, 0, 0); |
| |
| gcc_jit_rvalue *vals[] = { rval_f1, rval_i2}; |
| gcc_jit_field *fields[] = {fi_f, fi_i}; |
| |
| gcc_jit_rvalue *ctor = gcc_jit_context_new_struct_constructor |
| (ctxt, 0, |
| struct_fi_type, |
| 2, |
| fields, |
| vals); |
| gcc_jit_block_add_assignment (block, 0, local, ctor); |
| } |
| |
| gcc_jit_block_end_with_return (block, |
| 0, |
| gcc_jit_lvalue_as_rvalue(local)); |
| } |
| { /* struct fi foo(fi) { return fi;} |
| struct fi bar() { return foo((struct fi){3, 4}); } |
| */ |
| |
| gcc_jit_param *fi_param = |
| gcc_jit_context_new_param (ctxt, 0, struct_fi_type, "fi"); |
| |
| gcc_jit_function *fn0 = |
| gcc_jit_context_new_function (ctxt, |
| 0, |
| GCC_JIT_FUNCTION_EXPORTED, |
| struct_fi_type, |
| "fn_fi_x_x", |
| 1, |
| &fi_param, |
| 0); |
| gcc_jit_block *block0 = gcc_jit_function_new_block (fn0, "start"); |
| gcc_jit_block_end_with_return (block0, |
| 0, |
| gcc_jit_param_as_rvalue ( |
| gcc_jit_function_get_param (fn0, 0))); |
| |
| gcc_jit_function *fn = |
| gcc_jit_context_new_function (ctxt, |
| 0, |
| GCC_JIT_FUNCTION_EXPORTED, |
| struct_fi_type, |
| "fn_fi_3_4", |
| 0, |
| 0, |
| 0); |
| gcc_jit_block *block = gcc_jit_function_new_block (fn, "start"); |
| |
| gcc_jit_rvalue *rval_f1 = gcc_jit_context_new_rvalue_from_int ( |
| ctxt, float_type, 3); |
| gcc_jit_rvalue *rval_i2 = gcc_jit_context_new_rvalue_from_int ( |
| ctxt, int_type, 4); |
| |
| gcc_jit_rvalue *vals[] = { rval_f1, rval_i2}; |
| gcc_jit_field *fields[] = {fi_f, fi_i}; |
| |
| gcc_jit_rvalue *ctor = gcc_jit_context_new_struct_constructor |
| (ctxt, 0, |
| struct_fi_type, |
| 2, |
| fields, |
| vals); |
| |
| gcc_jit_rvalue *call = gcc_jit_context_new_call (ctxt, 0, fn0, 1, &ctor); |
| |
| gcc_jit_block_end_with_return (block, |
| 0, |
| call); |
| } |
| { /* |
| void foo(struct bar *b) { *b = (struct bar) {.arr = {1,2}; } |
| */ |
| |
| gcc_jit_param *param = |
| gcc_jit_context_new_param (ctxt, 0, |
| gcc_jit_type_get_pointer (struct_bar_type), |
| "b"); |
| |
| |
| gcc_jit_function *fn = |
| gcc_jit_context_new_function (ctxt, |
| 0, |
| GCC_JIT_FUNCTION_EXPORTED, |
| void_type, |
| "fn_pbar_12", |
| 1, |
| ¶m, |
| 0); |
| gcc_jit_block *block = gcc_jit_function_new_block (fn, "start"); |
| |
| gcc_jit_rvalue *rval_i1 = gcc_jit_context_new_rvalue_from_int ( |
| ctxt, int_type, 1); |
| gcc_jit_rvalue *rval_i2 = gcc_jit_context_new_rvalue_from_int ( |
| ctxt, int_type, 2); |
| |
| gcc_jit_rvalue *arr_vals[] = { rval_i1, rval_i2}; |
| |
| gcc_jit_rvalue *arr_ctor = gcc_jit_context_new_array_constructor |
| (ctxt, 0, |
| int50arr_type, |
| 2, |
| arr_vals); |
| |
| gcc_jit_rvalue *str_ctor = gcc_jit_context_new_struct_constructor |
| (ctxt, |
| 0, |
| struct_bar_type, |
| 1, |
| &bar_fi, |
| &arr_ctor); |
| |
| gcc_jit_param *p0 = gcc_jit_function_get_param (fn, 0); |
| gcc_jit_lvalue *lv0 = gcc_jit_param_as_lvalue (p0); |
| gcc_jit_lvalue *deref = |
| gcc_jit_rvalue_dereference (gcc_jit_lvalue_as_rvalue (lv0), 0); |
| |
| gcc_jit_block_add_assignment (block, 0, |
| deref, |
| str_ctor); |
| |
| gcc_jit_block_end_with_void_return (block, 0); |
| } |
| { /* struct bar foo() { struct bar local = {}; |
| return local;} |
| */ |
| gcc_jit_function *fn = |
| gcc_jit_context_new_function (ctxt, |
| 0, |
| GCC_JIT_FUNCTION_EXPORTED, |
| struct_bar_type, |
| "fn_bar_0s", |
| 0, |
| 0, |
| 0); |
| gcc_jit_lvalue *local = |
| gcc_jit_function_new_local (fn, |
| 0, |
| struct_bar_type, |
| "local"); |
| gcc_jit_block *block = gcc_jit_function_new_block (fn, "start"); |
| |
| gcc_jit_rvalue *ctor = gcc_jit_context_new_struct_constructor |
| (ctxt, 0, |
| struct_bar_type, |
| 0, |
| 0, |
| 0); |
| gcc_jit_block_add_assignment (block, 0, local, ctor); |
| |
| gcc_jit_block_end_with_return (block, |
| 0, |
| gcc_jit_lvalue_as_rvalue(local)); |
| } |
| { /* struct bar foo() { struct bar local; |
| local.arr = (int [50]){1,2,3,4,5,6}; |
| return local;} |
| */ |
| gcc_jit_function *fn = |
| gcc_jit_context_new_function (ctxt, |
| 0, |
| GCC_JIT_FUNCTION_EXPORTED, |
| struct_bar_type, |
| "fn_bar_123s", |
| 0, |
| 0, |
| 0); |
| gcc_jit_lvalue *local = |
| gcc_jit_function_new_local (fn, |
| 0, |
| struct_bar_type, |
| "local"); |
| gcc_jit_block *block = gcc_jit_function_new_block (fn, "start"); |
| |
| gcc_jit_rvalue *values[6]; |
| |
| for (int i = 0; i < 6; i++) |
| values[i] = gcc_jit_context_new_rvalue_from_int (ctxt, int_type, i + 1); |
| |
| gcc_jit_rvalue *ctor = gcc_jit_context_new_array_constructor |
| (ctxt, 0, |
| int50arr_type, |
| 6, |
| values); |
| |
| gcc_jit_lvalue *arr_lv = gcc_jit_lvalue_access_field (local, |
| 0, |
| bar_fi); |
| gcc_jit_block_add_assignment (block, 0, arr_lv, ctor); |
| |
| gcc_jit_block_end_with_return (block, |
| 0, |
| gcc_jit_lvalue_as_rvalue(local)); |
| } |
| { /* int[50] foo() { int arr[50]; |
| arr = (int [50]){1,2,3,4,5,6}; |
| return arr;} |
| |
| N.B: Not a typo, returning an array. |
| */ |
| gcc_jit_function *fn = |
| gcc_jit_context_new_function (ctxt, |
| 0, |
| GCC_JIT_FUNCTION_EXPORTED, |
| int50arr_type, |
| "fn_int50arr_123s", |
| 0, |
| 0, |
| 0); |
| gcc_jit_lvalue *local = |
| gcc_jit_function_new_local (fn, |
| 0, |
| int50arr_type, |
| "local"); |
| gcc_jit_block *block = gcc_jit_function_new_block (fn, "start"); |
| |
| gcc_jit_rvalue *values[6]; |
| |
| for (int i = 0; i < 6; i++) |
| values[i] = gcc_jit_context_new_rvalue_from_int (ctxt, int_type, i + 1); |
| |
| gcc_jit_rvalue *ctor = gcc_jit_context_new_array_constructor ( |
| ctxt, |
| 0, |
| int50arr_type, |
| 6, |
| values); |
| |
| gcc_jit_block_add_assignment (block, 0, local, ctor); |
| |
| gcc_jit_block_end_with_return (block, |
| 0, |
| gcc_jit_lvalue_as_rvalue(local)); |
| } |
| { /* |
| Verify that circular linked lists compiles, .e.g. |
| that visit_children does not run in circles or something. |
| |
| struct llist { struct llist *next; }; |
| |
| bool foo (void) |
| { |
| volatile struct llist a; |
| volatile struct llist b; |
| |
| a = (struct llist) {.next = &b}; |
| b = (struct llist) {.next = &a}; |
| |
| return a.next == &b; |
| } |
| */ |
| gcc_jit_struct *llist = |
| gcc_jit_context_new_opaque_struct(ctxt, |
| 0, "llist_lcl"); |
| gcc_jit_field *fields[] = |
| { |
| gcc_jit_context_new_field (ctxt, 0, |
| gcc_jit_type_get_pointer ( |
| gcc_jit_struct_as_type (llist)), |
| "next") |
| }; |
| gcc_jit_struct_set_fields (llist, 0, 1, fields); |
| gcc_jit_type *t_llist = gcc_jit_struct_as_type (llist); |
| |
| gcc_jit_function *fn = |
| gcc_jit_context_new_function (ctxt, |
| 0, |
| GCC_JIT_FUNCTION_EXPORTED, |
| bool_type, |
| "fn_llist", |
| 0, |
| 0, |
| 0); |
| gcc_jit_block *block = gcc_jit_function_new_block (fn, "start"); |
| |
| gcc_jit_lvalue *a = |
| gcc_jit_function_new_local (fn, |
| 0, |
| gcc_jit_type_get_volatile (t_llist), |
| "a"); |
| gcc_jit_lvalue *b = |
| gcc_jit_function_new_local (fn, |
| 0, |
| gcc_jit_type_get_volatile (t_llist), |
| "b"); |
| |
| gcc_jit_rvalue *a_addr = gcc_jit_lvalue_get_address( a, 0); |
| gcc_jit_rvalue *b_addr = gcc_jit_lvalue_get_address( b, 0); |
| |
| gcc_jit_rvalue *a_ctor = gcc_jit_context_new_struct_constructor ( |
| ctxt, |
| 0, |
| t_llist, |
| 1, |
| 0, |
| &b_addr); |
| |
| gcc_jit_rvalue *b_ctor = gcc_jit_context_new_struct_constructor ( |
| ctxt, |
| 0, |
| t_llist, |
| 1, |
| 0, |
| &a_addr); |
| |
| gcc_jit_block_add_assignment (block, 0, |
| a, a_ctor); |
| gcc_jit_block_add_assignment (block, 0, |
| b, b_ctor); |
| |
| gcc_jit_rvalue *cmp = |
| gcc_jit_context_new_comparison ( |
| ctxt, 0, |
| GCC_JIT_COMPARISON_EQ, |
| gcc_jit_rvalue_access_field (gcc_jit_lvalue_as_rvalue (a), |
| 0, fields[0]), |
| gcc_jit_context_new_cast (ctxt, 0, |
| gcc_jit_lvalue_get_address (b, 0), |
| gcc_jit_type_get_pointer (t_llist))); |
| |
| gcc_jit_block_end_with_return (block, |
| 0, cmp); |
| } |
| } |
| |
| struct fi2 { |
| float f; |
| int i; |
| }; |
| |
| struct bar2 { |
| float ff; |
| int arr[50]; |
| int ii; |
| char c; |
| }; |
| |
| union ubar2 { |
| float ff; |
| int ii; |
| }; |
| |
| struct int50arr { |
| int arr[50]; |
| }; |
| |
| void __attribute__((optimize(0))) |
| scramble_stack(void) |
| { |
| char *p = alloca(100); |
| for (int i = 0; i < 100; i++) |
| *p++ = 0xF0; |
| asm(""); /* Mark for side-effect */ |
| } |
| |
| void __attribute__((optimize(0))) |
| scramble_arr (char *arr, int len) |
| { |
| for (int i = 0; i < len; i++) |
| *arr++ = i; |
| asm(""); /* Mark for side-effect */ |
| } |
| |
| void |
| verify_code (gcc_jit_context *ctxt, gcc_jit_result *result) |
| { |
| CHECK_NON_NULL (result); |
| |
| { |
| struct fi2 (*fn) (void) = gcc_jit_result_get_code (result, "fn_fi_1_2"); |
| scramble_stack (); |
| struct fi2 fi = fn (); |
| CHECK_VALUE (fi.f, 1); |
| CHECK_VALUE (fi.i, 2); |
| } |
| { |
| struct fi2 (*fn) (void) = gcc_jit_result_get_code (result, "fn_fi_5_6"); |
| struct fi2 fi = fn (); |
| CHECK_VALUE (fi.f, 5); |
| CHECK_VALUE (fi.i, 6); |
| } |
| { |
| struct fi2 (*fn) (void) = gcc_jit_result_get_code (result, "fn_fi_1_3"); |
| struct fi2 fi = fn (); |
| CHECK_VALUE (fi.f, 1); |
| CHECK_VALUE (fi.i, 3); |
| } |
| { |
| struct fi2 (*fn) (void) = gcc_jit_result_get_code (result, "fn_fi_3_4"); |
| struct fi2 fi = fn (); |
| CHECK_VALUE (fi.f, 3); |
| CHECK_VALUE (fi.i, 4); |
| } |
| { |
| scramble_stack(); |
| struct bar2 (*fn) (void) = gcc_jit_result_get_code (result, "fn_bar_0s"); |
| struct bar2 bar = fn (); |
| struct bar2 key = {}; |
| |
| CHECK_VALUE (bar.ff, 0); |
| CHECK_VALUE (bar.ii, 0); |
| CHECK_VALUE (memcmp (&bar.arr, &key.arr, sizeof (key.arr)), 0); |
| } |
| { |
| |
| void (*fn) (struct bar2 *) = gcc_jit_result_get_code (result, "fn_pbar_12"); |
| |
| struct bar2 bar = (struct bar2) {}; |
| |
| scramble_arr ((char*)&bar, sizeof bar); |
| scramble_stack(); |
| |
| fn (&bar); |
| |
| struct bar2 key = {.arr = {1,2}}; |
| __builtin_clear_padding (&key); |
| |
| CHECK_VALUE (memcmp (&bar, &key, sizeof (key)), 0); |
| } |
| { |
| scramble_stack(); |
| struct bar2 (*fn) (void) = gcc_jit_result_get_code (result, "fn_bar_123s"); |
| struct bar2 bar = fn (); |
| struct bar2 key = {.arr = {1,2,3,4,5,6} }; |
| |
| CHECK_VALUE (memcmp (&bar.arr, &key.arr, sizeof (key.arr)), 0); |
| } |
| { |
| scramble_stack (); |
| /* This is abit shady. Lets just pretend that array returns à la Fortran |
| is the same thing as returning a struct with an array in it in C. */ |
| struct int50arr (*fn) (void) = |
| gcc_jit_result_get_code (result, "fn_int50arr_123s"); |
| struct int50arr ans = fn (); |
| int key[50] = {1,2,3,4,5,6}; |
| |
| CHECK_VALUE (memcmp (ans.arr, key, sizeof (key)), 0); |
| } |
| { |
| _Bool (*fn) (void) = gcc_jit_result_get_code (result, "fn_llist"); |
| CHECK_VALUE (fn (), 1); |
| } |
| } |
