| /* |
| Default header file for malloc-2.8.x, written by Doug Lea |
| and released to the public domain, as explained at |
| http://creativecommons.org/licenses/publicdomain. |
| |
| last update: Mon Aug 15 08:55:52 2005 Doug Lea (dl at gee) |
| |
| This header is for ANSI C/C++ only. You can set any of |
| the following #defines before including: |
| |
| * If USE_DL_PREFIX is defined, it is assumed that malloc.c |
| was also compiled with this option, so all routines |
| have names starting with "dl". |
| |
| * If HAVE_USR_INCLUDE_MALLOC_H is defined, it is assumed that this |
| file will be #included AFTER <malloc.h>. This is needed only if |
| your system defines a struct mallinfo that is incompatible with the |
| standard one declared here. Otherwise, you can include this file |
| INSTEAD of your system system <malloc.h>. At least on ANSI, all |
| declarations should be compatible with system versions |
| |
| * If MSPACES is defined, declarations for mspace versions are included. |
| */ |
| |
| #ifndef MALLOC_280_H |
| #define MALLOC_280_H |
| |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| |
| #include <stddef.h> /* for size_t */ |
| |
| #if !ONLY_MSPACES |
| |
| /* Check an additional macro for the five primary functions */ |
| #if !defined(USE_DL_PREFIX) |
| #define dlcalloc calloc |
| #define dlfree free |
| #define dlmalloc malloc |
| #define dlmemalign memalign |
| #define dlrealloc realloc |
| #endif |
| |
| #ifndef USE_DL_PREFIX |
| #define dlvalloc valloc |
| #define dlpvalloc pvalloc |
| #define dlmallinfo mallinfo |
| #define dlmallopt mallopt |
| #define dlmalloc_trim malloc_trim |
| #define dlmalloc_walk_free_pages \ |
| malloc_walk_free_pages |
| #define dlmalloc_walk_heap \ |
| malloc_walk_heap |
| #define dlmalloc_stats malloc_stats |
| #define dlmalloc_usable_size malloc_usable_size |
| #define dlmalloc_footprint malloc_footprint |
| #define dlmalloc_max_allowed_footprint \ |
| malloc_max_allowed_footprint |
| #define dlmalloc_set_max_allowed_footprint \ |
| malloc_set_max_allowed_footprint |
| #define dlmalloc_max_footprint malloc_max_footprint |
| #define dlindependent_calloc independent_calloc |
| #define dlindependent_comalloc independent_comalloc |
| #endif /* USE_DL_PREFIX */ |
| |
| |
| /* |
| malloc(size_t n) |
| Returns a pointer to a newly allocated chunk of at least n bytes, or |
| null if no space is available, in which case errno is set to ENOMEM |
| on ANSI C systems. |
| |
| If n is zero, malloc returns a minimum-sized chunk. (The minimum |
| size is 16 bytes on most 32bit systems, and 32 bytes on 64bit |
| systems.) Note that size_t is an unsigned type, so calls with |
| arguments that would be negative if signed are interpreted as |
| requests for huge amounts of space, which will often fail. The |
| maximum supported value of n differs across systems, but is in all |
| cases less than the maximum representable value of a size_t. |
| */ |
| void* dlmalloc(size_t); |
| |
| /* |
| free(void* p) |
| Releases the chunk of memory pointed to by p, that had been previously |
| allocated using malloc or a related routine such as realloc. |
| It has no effect if p is null. If p was not malloced or already |
| freed, free(p) will by default cuase the current program to abort. |
| */ |
| void dlfree(void*); |
| |
| /* |
| calloc(size_t n_elements, size_t element_size); |
| Returns a pointer to n_elements * element_size bytes, with all locations |
| set to zero. |
| */ |
| void* dlcalloc(size_t, size_t); |
| |
| /* |
| realloc(void* p, size_t n) |
| Returns a pointer to a chunk of size n that contains the same data |
| as does chunk p up to the minimum of (n, p's size) bytes, or null |
| if no space is available. |
| |
| The returned pointer may or may not be the same as p. The algorithm |
| prefers extending p in most cases when possible, otherwise it |
| employs the equivalent of a malloc-copy-free sequence. |
| |
| If p is null, realloc is equivalent to malloc. |
| |
| If space is not available, realloc returns null, errno is set (if on |
| ANSI) and p is NOT freed. |
| |
| if n is for fewer bytes than already held by p, the newly unused |
| space is lopped off and freed if possible. realloc with a size |
| argument of zero (re)allocates a minimum-sized chunk. |
| |
| The old unix realloc convention of allowing the last-free'd chunk |
| to be used as an argument to realloc is not supported. |
| */ |
| |
| void* dlrealloc(void*, size_t); |
| |
| /* |
| memalign(size_t alignment, size_t n); |
| Returns a pointer to a newly allocated chunk of n bytes, aligned |
| in accord with the alignment argument. |
| |
| The alignment argument should be a power of two. If the argument is |
| not a power of two, the nearest greater power is used. |
| 8-byte alignment is guaranteed by normal malloc calls, so don't |
| bother calling memalign with an argument of 8 or less. |
| |
| Overreliance on memalign is a sure way to fragment space. |
| */ |
| void* dlmemalign(size_t, size_t); |
| |
| /* |
| valloc(size_t n); |
| Equivalent to memalign(pagesize, n), where pagesize is the page |
| size of the system. If the pagesize is unknown, 4096 is used. |
| */ |
| void* dlvalloc(size_t); |
| |
| /* |
| mallopt(int parameter_number, int parameter_value) |
| Sets tunable parameters The format is to provide a |
| (parameter-number, parameter-value) pair. mallopt then sets the |
| corresponding parameter to the argument value if it can (i.e., so |
| long as the value is meaningful), and returns 1 if successful else |
| 0. SVID/XPG/ANSI defines four standard param numbers for mallopt, |
| normally defined in malloc.h. None of these are use in this malloc, |
| so setting them has no effect. But this malloc also supports other |
| options in mallopt: |
| |
| Symbol param # default allowed param values |
| M_TRIM_THRESHOLD -1 2*1024*1024 any (-1U disables trimming) |
| M_GRANULARITY -2 page size any power of 2 >= page size |
| M_MMAP_THRESHOLD -3 256*1024 any (or 0 if no MMAP support) |
| */ |
| int dlmallopt(int, int); |
| |
| #define M_TRIM_THRESHOLD (-1) |
| #define M_GRANULARITY (-2) |
| #define M_MMAP_THRESHOLD (-3) |
| |
| |
| /* |
| malloc_footprint(); |
| Returns the number of bytes obtained from the system. The total |
| number of bytes allocated by malloc, realloc etc., is less than this |
| value. Unlike mallinfo, this function returns only a precomputed |
| result, so can be called frequently to monitor memory consumption. |
| Even if locks are otherwise defined, this function does not use them, |
| so results might not be up to date. |
| */ |
| size_t dlmalloc_footprint(); |
| |
| /* |
| malloc_max_allowed_footprint(); |
| Returns the number of bytes that the heap is allowed to obtain |
| from the system. malloc_footprint() should always return a |
| size less than or equal to max_allowed_footprint, unless the |
| max_allowed_footprint was set to a value smaller than the |
| footprint at the time. |
| |
| This function is only available if dlmalloc.c was compiled |
| with USE_MAX_ALLOWED_FOOTPRINT set. |
| */ |
| size_t dlmalloc_max_allowed_footprint(); |
| |
| /* |
| malloc_set_max_allowed_footprint(); |
| Set the maximum number of bytes that the heap is allowed to |
| obtain from the system. The size will be rounded up to a whole |
| page, and the rounded number will be returned from future calls |
| to malloc_max_allowed_footprint(). If the new max_allowed_footprint |
| is larger than the current footprint, the heap will never grow |
| larger than max_allowed_footprint. If the new max_allowed_footprint |
| is smaller than the current footprint, the heap will not grow |
| further. |
| |
| This function is only available if dlmalloc.c was compiled |
| with USE_MAX_ALLOWED_FOOTPRINT set. |
| |
| TODO: try to force the heap to give up memory in the shrink case, |
| and update this comment once that happens. |
| */ |
| void dlmalloc_set_max_allowed_footprint(size_t bytes); |
| |
| /* |
| malloc_max_footprint(); |
| Returns the maximum number of bytes obtained from the system. This |
| value will be greater than current footprint if deallocated space |
| has been reclaimed by the system. The peak number of bytes allocated |
| by malloc, realloc etc., is less than this value. Unlike mallinfo, |
| this function returns only a precomputed result, so can be called |
| frequently to monitor memory consumption. Even if locks are |
| otherwise defined, this function does not use them, so results might |
| not be up to date. |
| */ |
| size_t dlmalloc_max_footprint(void); |
| |
| #if !NO_MALLINFO |
| /* |
| mallinfo() |
| Returns (by copy) a struct containing various summary statistics: |
| |
| arena: current total non-mmapped bytes allocated from system |
| ordblks: the number of free chunks |
| smblks: always zero. |
| hblks: current number of mmapped regions |
| hblkhd: total bytes held in mmapped regions |
| usmblks: the maximum total allocated space. This will be greater |
| than current total if trimming has occurred. |
| fsmblks: always zero |
| uordblks: current total allocated space (normal or mmapped) |
| fordblks: total free space |
| keepcost: the maximum number of bytes that could ideally be released |
| back to system via malloc_trim. ("ideally" means that |
| it ignores page restrictions etc.) |
| |
| Because these fields are ints, but internal bookkeeping may |
| be kept as longs, the reported values may wrap around zero and |
| thus be inaccurate. |
| */ |
| #ifndef HAVE_USR_INCLUDE_MALLOC_H |
| #ifndef _MALLOC_H_ |
| #ifndef MALLINFO_FIELD_TYPE |
| #define MALLINFO_FIELD_TYPE size_t |
| #endif /* MALLINFO_FIELD_TYPE */ |
| struct mallinfo { |
| MALLINFO_FIELD_TYPE arena; /* non-mmapped space allocated from system */ |
| MALLINFO_FIELD_TYPE ordblks; /* number of free chunks */ |
| MALLINFO_FIELD_TYPE smblks; /* always 0 */ |
| MALLINFO_FIELD_TYPE hblks; /* always 0 */ |
| MALLINFO_FIELD_TYPE hblkhd; /* space in mmapped regions */ |
| MALLINFO_FIELD_TYPE usmblks; /* maximum total allocated space */ |
| MALLINFO_FIELD_TYPE fsmblks; /* always 0 */ |
| MALLINFO_FIELD_TYPE uordblks; /* total allocated space */ |
| MALLINFO_FIELD_TYPE fordblks; /* total free space */ |
| MALLINFO_FIELD_TYPE keepcost; /* releasable (via malloc_trim) space */ |
| }; |
| #endif /* _MALLOC_H_ */ |
| #endif /* HAVE_USR_INCLUDE_MALLOC_H */ |
| |
| struct mallinfo dlmallinfo(void); |
| #endif /* NO_MALLINFO */ |
| |
| /* |
| independent_calloc(size_t n_elements, size_t element_size, void* chunks[]); |
| |
| independent_calloc is similar to calloc, but instead of returning a |
| single cleared space, it returns an array of pointers to n_elements |
| independent elements that can hold contents of size elem_size, each |
| of which starts out cleared, and can be independently freed, |
| realloc'ed etc. The elements are guaranteed to be adjacently |
| allocated (this is not guaranteed to occur with multiple callocs or |
| mallocs), which may also improve cache locality in some |
| applications. |
| |
| The "chunks" argument is optional (i.e., may be null, which is |
| probably the most typical usage). If it is null, the returned array |
| is itself dynamically allocated and should also be freed when it is |
| no longer needed. Otherwise, the chunks array must be of at least |
| n_elements in length. It is filled in with the pointers to the |
| chunks. |
| |
| In either case, independent_calloc returns this pointer array, or |
| null if the allocation failed. If n_elements is zero and "chunks" |
| is null, it returns a chunk representing an array with zero elements |
| (which should be freed if not wanted). |
| |
| Each element must be individually freed when it is no longer |
| needed. If you'd like to instead be able to free all at once, you |
| should instead use regular calloc and assign pointers into this |
| space to represent elements. (In this case though, you cannot |
| independently free elements.) |
| |
| independent_calloc simplifies and speeds up implementations of many |
| kinds of pools. It may also be useful when constructing large data |
| structures that initially have a fixed number of fixed-sized nodes, |
| but the number is not known at compile time, and some of the nodes |
| may later need to be freed. For example: |
| |
| struct Node { int item; struct Node* next; }; |
| |
| struct Node* build_list() { |
| struct Node** pool; |
| int n = read_number_of_nodes_needed(); |
| if (n <= 0) return 0; |
| pool = (struct Node**)(independent_calloc(n, sizeof(struct Node), 0); |
| if (pool == 0) die(); |
| // organize into a linked list... |
| struct Node* first = pool[0]; |
| for (i = 0; i < n-1; ++i) |
| pool[i]->next = pool[i+1]; |
| free(pool); // Can now free the array (or not, if it is needed later) |
| return first; |
| } |
| */ |
| void** dlindependent_calloc(size_t, size_t, void**); |
| |
| /* |
| independent_comalloc(size_t n_elements, size_t sizes[], void* chunks[]); |
| |
| independent_comalloc allocates, all at once, a set of n_elements |
| chunks with sizes indicated in the "sizes" array. It returns |
| an array of pointers to these elements, each of which can be |
| independently freed, realloc'ed etc. The elements are guaranteed to |
| be adjacently allocated (this is not guaranteed to occur with |
| multiple callocs or mallocs), which may also improve cache locality |
| in some applications. |
| |
| The "chunks" argument is optional (i.e., may be null). If it is null |
| the returned array is itself dynamically allocated and should also |
| be freed when it is no longer needed. Otherwise, the chunks array |
| must be of at least n_elements in length. It is filled in with the |
| pointers to the chunks. |
| |
| In either case, independent_comalloc returns this pointer array, or |
| null if the allocation failed. If n_elements is zero and chunks is |
| null, it returns a chunk representing an array with zero elements |
| (which should be freed if not wanted). |
| |
| Each element must be individually freed when it is no longer |
| needed. If you'd like to instead be able to free all at once, you |
| should instead use a single regular malloc, and assign pointers at |
| particular offsets in the aggregate space. (In this case though, you |
| cannot independently free elements.) |
| |
| independent_comallac differs from independent_calloc in that each |
| element may have a different size, and also that it does not |
| automatically clear elements. |
| |
| independent_comalloc can be used to speed up allocation in cases |
| where several structs or objects must always be allocated at the |
| same time. For example: |
| |
| struct Head { ... } |
| struct Foot { ... } |
| |
| void send_message(char* msg) { |
| int msglen = strlen(msg); |
| size_t sizes[3] = { sizeof(struct Head), msglen, sizeof(struct Foot) }; |
| void* chunks[3]; |
| if (independent_comalloc(3, sizes, chunks) == 0) |
| die(); |
| struct Head* head = (struct Head*)(chunks[0]); |
| char* body = (char*)(chunks[1]); |
| struct Foot* foot = (struct Foot*)(chunks[2]); |
| // ... |
| } |
| |
| In general though, independent_comalloc is worth using only for |
| larger values of n_elements. For small values, you probably won't |
| detect enough difference from series of malloc calls to bother. |
| |
| Overuse of independent_comalloc can increase overall memory usage, |
| since it cannot reuse existing noncontiguous small chunks that |
| might be available for some of the elements. |
| */ |
| void** dlindependent_comalloc(size_t, size_t*, void**); |
| |
| |
| /* |
| pvalloc(size_t n); |
| Equivalent to valloc(minimum-page-that-holds(n)), that is, |
| round up n to nearest pagesize. |
| */ |
| void* dlpvalloc(size_t); |
| |
| /* |
| malloc_trim(size_t pad); |
| |
| If possible, gives memory back to the system (via negative arguments |
| to sbrk) if there is unused memory at the `high' end of the malloc |
| pool or in unused MMAP segments. You can call this after freeing |
| large blocks of memory to potentially reduce the system-level memory |
| requirements of a program. However, it cannot guarantee to reduce |
| memory. Under some allocation patterns, some large free blocks of |
| memory will be locked between two used chunks, so they cannot be |
| given back to the system. |
| |
| The `pad' argument to malloc_trim represents the amount of free |
| trailing space to leave untrimmed. If this argument is zero, only |
| the minimum amount of memory to maintain internal data structures |
| will be left. Non-zero arguments can be supplied to maintain enough |
| trailing space to service future expected allocations without having |
| to re-obtain memory from the system. |
| |
| Malloc_trim returns 1 if it actually released any memory, else 0. |
| */ |
| int dlmalloc_trim(size_t); |
| |
| /* |
| malloc_walk_free_pages(handler, harg) |
| |
| Calls the provided handler on each free region in the heap. The |
| memory between start and end are guaranteed not to contain any |
| important data, so the handler is free to alter the contents |
| in any way. This can be used to advise the OS that large free |
| regions may be swapped out. |
| |
| The value in harg will be passed to each call of the handler. |
| */ |
| void dlmalloc_walk_free_pages(void(*handler)(void *start, void *end, void *arg), |
| void *harg); |
| |
| /* |
| malloc_walk_heap(handler, harg) |
| |
| Calls the provided handler on each object or free region in the |
| heap. The handler will receive the chunk pointer and length, the |
| object pointer and length, and the value in harg on each call. |
| */ |
| void dlmalloc_walk_heap(void(*handler)(const void *chunkptr, size_t chunklen, |
| const void *userptr, size_t userlen, |
| void *arg), |
| void *harg); |
| |
| /* |
| malloc_usable_size(void* p); |
| |
| Returns the number of bytes you can actually use in |
| an allocated chunk, which may be more than you requested (although |
| often not) due to alignment and minimum size constraints. |
| You can use this many bytes without worrying about |
| overwriting other allocated objects. This is not a particularly great |
| programming practice. malloc_usable_size can be more useful in |
| debugging and assertions, for example: |
| |
| p = malloc(n); |
| assert(malloc_usable_size(p) >= 256); |
| */ |
| size_t dlmalloc_usable_size(void*); |
| |
| /* |
| malloc_stats(); |
| Prints on stderr the amount of space obtained from the system (both |
| via sbrk and mmap), the maximum amount (which may be more than |
| current if malloc_trim and/or munmap got called), and the current |
| number of bytes allocated via malloc (or realloc, etc) but not yet |
| freed. Note that this is the number of bytes allocated, not the |
| number requested. It will be larger than the number requested |
| because of alignment and bookkeeping overhead. Because it includes |
| alignment wastage as being in use, this figure may be greater than |
| zero even when no user-level chunks are allocated. |
| |
| The reported current and maximum system memory can be inaccurate if |
| a program makes other calls to system memory allocation functions |
| (normally sbrk) outside of malloc. |
| |
| malloc_stats prints only the most commonly interesting statistics. |
| More information can be obtained by calling mallinfo. |
| */ |
| void dlmalloc_stats(); |
| |
| #endif /* !ONLY_MSPACES */ |
| |
| #if MSPACES |
| |
| /* |
| mspace is an opaque type representing an independent |
| region of space that supports mspace_malloc, etc. |
| */ |
| typedef void* mspace; |
| |
| /* |
| create_mspace creates and returns a new independent space with the |
| given initial capacity, or, if 0, the default granularity size. It |
| returns null if there is no system memory available to create the |
| space. If argument locked is non-zero, the space uses a separate |
| lock to control access. The capacity of the space will grow |
| dynamically as needed to service mspace_malloc requests. You can |
| control the sizes of incremental increases of this space by |
| compiling with a different DEFAULT_GRANULARITY or dynamically |
| setting with mallopt(M_GRANULARITY, value). |
| */ |
| mspace create_mspace(size_t capacity, int locked); |
| |
| /* |
| destroy_mspace destroys the given space, and attempts to return all |
| of its memory back to the system, returning the total number of |
| bytes freed. After destruction, the results of access to all memory |
| used by the space become undefined. |
| */ |
| size_t destroy_mspace(mspace msp); |
| |
| /* |
| create_mspace_with_base uses the memory supplied as the initial base |
| of a new mspace. Part (less than 128*sizeof(size_t) bytes) of this |
| space is used for bookkeeping, so the capacity must be at least this |
| large. (Otherwise 0 is returned.) When this initial space is |
| exhausted, additional memory will be obtained from the system. |
| Destroying this space will deallocate all additionally allocated |
| space (if possible) but not the initial base. |
| */ |
| mspace create_mspace_with_base(void* base, size_t capacity, int locked); |
| |
| /* |
| mspace_malloc behaves as malloc, but operates within |
| the given space. |
| */ |
| void* mspace_malloc(mspace msp, size_t bytes); |
| |
| /* |
| mspace_free behaves as free, but operates within |
| the given space. |
| |
| If compiled with FOOTERS==1, mspace_free is not actually needed. |
| free may be called instead of mspace_free because freed chunks from |
| any space are handled by their originating spaces. |
| */ |
| void mspace_free(mspace msp, void* mem); |
| |
| /* |
| mspace_realloc behaves as realloc, but operates within |
| the given space. |
| |
| If compiled with FOOTERS==1, mspace_realloc is not actually |
| needed. realloc may be called instead of mspace_realloc because |
| realloced chunks from any space are handled by their originating |
| spaces. |
| */ |
| void* mspace_realloc(mspace msp, void* mem, size_t newsize); |
| |
| /* |
| mspace_merge_objects will merge allocated memory mema and memb |
| together, provided memb immediately follows mema. It is roughly as |
| if memb has been freed and mema has been realloced to a larger size. |
| On successfully merging, mema will be returned. If either argument |
| is null or memb does not immediately follow mema, null will be |
| returned. |
| |
| Both mema and memb should have been previously allocated using |
| malloc or a related routine such as realloc. If either mema or memb |
| was not malloced or was previously freed, the result is undefined, |
| but like mspace_free, the default is to abort the program. |
| */ |
| void* mspace_merge_objects(mspace msp, void* mema, void* memb); |
| |
| /* |
| mspace_calloc behaves as calloc, but operates within |
| the given space. |
| */ |
| void* mspace_calloc(mspace msp, size_t n_elements, size_t elem_size); |
| |
| /* |
| mspace_memalign behaves as memalign, but operates within |
| the given space. |
| */ |
| void* mspace_memalign(mspace msp, size_t alignment, size_t bytes); |
| |
| /* |
| mspace_independent_calloc behaves as independent_calloc, but |
| operates within the given space. |
| */ |
| void** mspace_independent_calloc(mspace msp, size_t n_elements, |
| size_t elem_size, void* chunks[]); |
| |
| /* |
| mspace_independent_comalloc behaves as independent_comalloc, but |
| operates within the given space. |
| */ |
| void** mspace_independent_comalloc(mspace msp, size_t n_elements, |
| size_t sizes[], void* chunks[]); |
| |
| /* |
| mspace_footprint() returns the number of bytes obtained from the |
| system for this space. |
| */ |
| size_t mspace_footprint(mspace msp); |
| |
| /* |
| mspace_max_allowed_footprint() returns the number of bytes that |
| this space is allowed to obtain from the system. See |
| malloc_max_allowed_footprint() for a more in-depth description. |
| |
| This function is only available if dlmalloc.c was compiled |
| with USE_MAX_ALLOWED_FOOTPRINT set. |
| */ |
| size_t mspace_max_allowed_footprint(mspace msp); |
| |
| /* |
| mspace_set_max_allowed_footprint() sets the maximum number of |
| bytes (rounded up to a page) that this space is allowed to |
| obtain from the system. See malloc_set_max_allowed_footprint() |
| for a more in-depth description. |
| |
| This function is only available if dlmalloc.c was compiled |
| with USE_MAX_ALLOWED_FOOTPRINT set. |
| */ |
| void mspace_set_max_allowed_footprint(mspace msp, size_t bytes); |
| |
| /* |
| mspace_max_footprint() returns the maximum number of bytes obtained |
| from the system over the lifetime of this space. |
| */ |
| size_t mspace_max_footprint(mspace msp); |
| |
| |
| #if !NO_MALLINFO |
| /* |
| mspace_mallinfo behaves as mallinfo, but reports properties of |
| the given space. |
| */ |
| struct mallinfo mspace_mallinfo(mspace msp); |
| #endif /* NO_MALLINFO */ |
| |
| /* |
| mspace_malloc_stats behaves as malloc_stats, but reports |
| properties of the given space. |
| */ |
| void mspace_malloc_stats(mspace msp); |
| |
| /* |
| mspace_trim behaves as malloc_trim, but |
| operates within the given space. |
| */ |
| int mspace_trim(mspace msp, size_t pad); |
| |
| /* |
| An alias for mallopt. |
| */ |
| int mspace_mallopt(int, int); |
| |
| #endif /* MSPACES */ |
| |
| #ifdef __cplusplus |
| }; /* end of extern "C" */ |
| #endif |
| |
| #endif /* MALLOC_280_H */ |