lsp.log

[ START ] 2021-07-03T20:16:11+0300 ] LSP logging initiated
[ START ] 2021-07-03T20:16:24+0300 ] LSP logging initiated
[ START ] 2021-07-03T20:15:23+0300 ] LSP logging initiated
[ START ] 2021-07-03T20:18:13+0300 ] LSP logging initiated
[ START ] 2021-07-03T20:18:27+0300 ] LSP logging initiated
[ START ] 2021-07-03T20:18:35+0300 ] LSP logging initiated
[ START ] 2021-07-03T20:18:50+0300 ] LSP logging initiated
[ START ] 2021-07-03T20:19:56+0300 ] LSP logging initiated
[ START ] 2021-07-03T20:20:52+0300 ] LSP logging initiated
[ START ] 2021-07-03T20:21:01+0300 ] LSP logging initiated
[ START ] 2021-07-03T20:22:31+0300 ] LSP logging initiated
[ START ] 2021-07-03T20:21:27+0300 ] LSP logging initiated
[ START ] 2021-07-04T13:00:32+0300 ] LSP logging initiated
[ START ] 2021-07-04T13:05:51+0300 ] LSP logging initiated
[ START ] 2021-07-04T13:09:23+0300 ] LSP logging initiated
[ START ] 2021-07-04T13:01:49+0300 ] LSP logging initiated
[ START ] 2021-07-04T13:12:18+0300 ] LSP logging initiated
[ START ] 2021-07-04T15:14:32+0300 ] LSP logging initiated
[ START ] 2021-07-04T16:05:03+0300 ] LSP logging initiated
[ START ] 2021-07-04T16:05:13+0300 ] LSP logging initiated
[ START ] 2021-07-04T16:06:35+0300 ] LSP logging initiated
[ START ] 2021-07-04T18:33:35+0300 ] LSP logging initiated
[ START ] 2021-07-04T18:34:17+0300 ] LSP logging initiated
[ START ] 2021-07-05T12:19:44+0300 ] LSP logging initiated
[ START ] 2021-07-05T15:12:40+0300 ] LSP logging initiated
[ START ] 2021-07-05T15:13:05+0300 ] LSP logging initiated
[ START ] 2021-07-05T17:02:30+0300 ] LSP logging initiated
[ START ] 2021-07-05T17:06:35+0300 ] LSP logging initiated
[ START ] 2021-07-05T17:06:55+0300 ] LSP logging initiated
[ START ] 2021-07-05T17:07:10+0300 ] LSP logging initiated
[ START ] 2021-07-05T17:10:24+0300 ] LSP logging initiated
[ START ] 2021-07-05T17:24:23+0300 ] LSP logging initiated
[ START ] 2021-07-05T17:28:28+0300 ] LSP logging initiated
[ START ] 2021-07-05T17:58:49+0300 ] LSP logging initiated
[ START ] 2021-07-05T19:03:54+0300 ] LSP logging initiated
[ START ] 2021-07-05T18:00:03+0300 ] LSP logging initiated
[ START ] 2021-07-05T19:13:24+0300 ] LSP logging initiated
[ START ] 2021-07-05T19:15:01+0300 ] LSP logging initiated
[ START ] 2021-07-05T19:15:50+0300 ] LSP logging initiated
[ START ] 2021-07-05T19:21:54+0300 ] LSP logging initiated
[ START ] 2021-07-05T20:20:39+0300 ] LSP logging initiated
[ START ] 2021-07-05T22:43:08+0300 ] LSP logging initiated
[ START ] 2021-07-05T22:53:45+0300 ] LSP logging initiated
[ START ] 2021-07-06T12:48:21+0300 ] LSP logging initiated
[ START ] 2021-07-07T13:30:17+0300 ] LSP logging initiated
[ START ] 2021-07-07T13:31:24+0300 ] LSP logging initiated
[ START ] 2021-07-07T13:54:38+0300 ] LSP logging initiated
[ START ] 2021-07-07T15:49:27+0300 ] LSP logging initiated
[ START ] 2021-07-07T16:29:50+0300 ] LSP logging initiated
[ START ] 2021-07-07T16:24:21+0300 ] LSP logging initiated
[ START ] 2021-07-07T16:53:36+0300 ] LSP logging initiated
[ START ] 2021-07-07T21:41:30+0300 ] LSP logging initiated
[ START ] 2021-07-07T22:38:54+0300 ] LSP logging initiated
[ START ] 2021-07-08T14:10:00+0300 ] LSP logging initiated
[ START ] 2021-07-08T13:41:17+0300 ] LSP logging initiated
[ START ] 2021-07-08T14:22:58+0300 ] LSP logging initiated
[ START ] 2021-07-08T14:14:58+0300 ] LSP logging initiated
[ START ] 2021-07-08T16:05:12+0300 ] LSP logging initiated
[ START ] 2021-07-08T16:19:24+0300 ] LSP logging initiated
[ START ] 2021-07-08T16:32:33+0300 ] LSP logging initiated
[ START ] 2021-07-08T18:24:51+0300 ] LSP logging initiated
[ START ] 2021-07-09T17:02:10+0300 ] LSP logging initiated
[ START ] 2021-07-09T17:02:43+0300 ] LSP logging initiated
[ START ] 2021-07-10T14:01:28+0300 ] LSP logging initiated
[ START ] 2021-07-10T14:02:49+0300 ] LSP logging initiated
[ START ] 2021-07-10T15:28:04+0300 ] LSP logging initiated
[ START ] 2021-07-10T18:55:47+0300 ] LSP logging initiated
[ START ] 2021-07-10T18:05:30+0300 ] LSP logging initiated
[ START ] 2021-07-10T18:57:10+0300 ] LSP logging initiated
[ START ] 2021-07-10T19:37:31+0300 ] LSP logging initiated
[ START ] 2021-07-10T19:01:17+0300 ] LSP logging initiated
[ START ] 2021-07-11T14:35:12+0300 ] LSP logging initiated
[ START ] 2021-07-11T14:58:09+0300 ] LSP logging initiated
[ START ] 2021-07-11T22:28:05+0300 ] LSP logging initiated
[ START ] 2021-07-11T22:28:57+0300 ] LSP logging initiated
[ START ] 2021-07-11T22:29:15+0300 ] LSP logging initiated
[ START ] 2021-07-11T22:32:51+0300 ] LSP logging initiated
[ START ] 2021-07-11T22:38:16+0300 ] LSP logging initiated
[ START ] 2021-07-11T23:17:11+0300 ] LSP logging initiated
[ START ] 2021-07-12T00:58:22+0300 ] LSP logging initiated
[ START ] 2021-07-12T01:08:15+0300 ] LSP logging initiated
[ START ] 2021-07-12T00:39:57+0300 ] LSP logging initiated
[ START ] 2021-07-12T02:09:42+0300 ] LSP logging initiated
[ START ] 2021-07-12T21:20:14+0300 ] LSP logging initiated
[ START ] 2021-07-12T21:20:34+0300 ] LSP logging initiated
[ START ] 2021-07-12T21:35:20+0300 ] LSP logging initiated
[ START ] 2021-07-12T21:32:18+0300 ] LSP logging initiated
[ START ] 2021-07-12T21:35:37+0300 ] LSP logging initiated
[ START ] 2021-07-12T21:32:54+0300 ] LSP logging initiated
[ START ] 2021-07-13T09:13:13+0300 ] LSP logging initiated
[ START ] 2021-07-13T09:15:41+0300 ] LSP logging initiated
[ START ] 2021-07-13T09:18:16+0300 ] LSP logging initiated
[ START ] 2021-07-13T18:44:08+0300 ] LSP logging initiated
[ START ] 2021-07-15T16:11:32+0300 ] LSP logging initiated
[ START ] 2021-07-15T16:14:11+0300 ] LSP logging initiated
[ START ] 2021-07-15T16:15:42+0300 ] LSP logging initiated
[ START ] 2021-07-15T16:05:17+0300 ] LSP logging initiated
[ START ] 2021-07-15T16:31:10+0300 ] LSP logging initiated
[ START ] 2021-07-15T21:03:07+0300 ] LSP logging initiated
[ START ] 2021-07-15T21:05:41+0300 ] LSP logging initiated
[ START ] 2021-07-15T22:57:31+0300 ] LSP logging initiated
[ START ] 2021-07-16T06:58:20+0300 ] LSP logging initiated
[ START ] 2021-07-16T06:58:13+0300 ] LSP logging initiated
[ START ] 2021-07-17T03:28:19+0300 ] LSP logging initiated
[ START ] 2021-07-17T03:28:47+0300 ] LSP logging initiated
[ START ] 2021-07-17T10:41:30+0300 ] LSP logging initiated
[ START ] 2021-07-17T10:41:47+0300 ] LSP logging initiated
[ START ] 2021-07-17T10:43:48+0300 ] LSP logging initiated
[ START ] 2021-07-18T19:08:17+0300 ] LSP logging initiated
[ START ] 2021-07-19T03:17:52+0300 ] LSP logging initiated
[ START ] 2021-07-19T03:52:31+0300 ] LSP logging initiated
[ START ] 2021-07-19T03:54:32+0300 ] LSP logging initiated
[ START ] 2021-07-19T03:54:45+0300 ] LSP logging initiated
[ START ] 2021-07-19T03:55:39+0300 ] LSP logging initiated
[ START ] 2021-07-19T03:56:51+0300 ] LSP logging initiated
[ START ] 2021-07-19T03:57:43+0300 ] LSP logging initiated
[ START ] 2021-07-19T03:57:51+0300 ] LSP logging initiated
[ START ] 2021-07-19T03:58:17+0300 ] LSP logging initiated
[ START ] 2021-07-19T03:58:22+0300 ] LSP logging initiated
[ START ] 2021-07-19T07:59:38+0300 ] LSP logging initiated
[ START ] 2021-07-19T21:02:06+0300 ] LSP logging initiated
[ START ] 2021-07-20T00:29:57+0300 ] LSP logging initiated
[ START ] 2021-07-20T00:56:22+0300 ] LSP logging initiated
[ START ] 2021-07-20T01:01:18+0300 ] LSP logging initiated
[ START ] 2021-07-20T02:25:46+0300 ] LSP logging initiated
[ START ] 2021-07-20T03:10:14+0300 ] LSP logging initiated
[ START ] 2021-07-20T06:27:47+0300 ] LSP logging initiated
[ START ] 2021-07-20T06:54:32+0300 ] LSP logging initiated
[ START ] 2021-07-20T06:54:39+0300 ] LSP logging initiated
[ START ] 2021-07-20T07:05:11+0300 ] LSP logging initiated
[ START ] 2021-07-20T07:05:30+0300 ] LSP logging initiated
[ START ] 2021-07-20T07:21:12+0300 ] LSP logging initiated
[ START ] 2021-07-20T09:17:19+0300 ] LSP logging initiated
[ START ] 2021-07-21T00:03:28+0300 ] LSP logging initiated
[ START ] 2021-07-21T04:30:46+0300 ] LSP logging initiated
[ START ] 2021-07-21T04:33:24+0300 ] LSP logging initiated
[ START ] 2021-07-21T04:55:09+0300 ] LSP logging initiated
[ START ] 2021-07-21T04:39:41+0300 ] LSP logging initiated
[ START ] 2021-07-21T12:17:31+0300 ] LSP logging initiated
[ START ] 2021-07-22T00:33:49+0300 ] LSP logging initiated
[ START ] 2021-07-22T00:42:05+0300 ] LSP logging initiated
[ START ] 2021-07-22T00:59:55+0300 ] LSP logging initiated
[ START ] 2021-07-22T00:49:51+0300 ] LSP logging initiated
[ START ] 2021-07-22T01:16:48+0300 ] LSP logging initiated
[ START ] 2021-07-22T01:27:52+0300 ] LSP logging initiated
[ START ] 2021-07-22T01:15:22+0300 ] LSP logging initiated
[ START ] 2021-07-22T01:40:33+0300 ] LSP logging initiated
[ START ] 2021-07-22T02:06:07+0300 ] LSP logging initiated
[ START ] 2021-07-22T07:41:30+0300 ] LSP logging initiated
[ START ] 2021-07-22T07:37:00+0300 ] LSP logging initiated
[ START ] 2021-07-22T22:21:49+0300 ] LSP logging initiated
[ START ] 2021-07-23T00:47:21+0300 ] LSP logging initiated
[ START ] 2021-07-23T01:10:31+0300 ] LSP logging initiated
[ START ] 2021-07-23T07:55:22+0300 ] LSP logging initiated
[ START ] 2021-07-24T06:13:11+0300 ] LSP logging initiated
[ START ] 2021-07-24T08:23:15+0300 ] LSP logging initiated
[ START ] 2021-07-24T07:57:21+0300 ] LSP logging initiated
[ START ] 2021-07-25T09:03:09+0300 ] LSP logging initiated
[ START ] 2021-07-25T09:31:24+0300 ] LSP logging initiated
[ START ] 2021-07-25T09:33:46+0300 ] LSP logging initiated
[ START ] 2021-07-25T09:36:01+0300 ] LSP logging initiated
[ START ] 2021-07-25T09:38:28+0300 ] LSP logging initiated
[ START ] 2021-07-25T14:29:08+0300 ] LSP logging initiated
[ START ] 2021-07-26T09:20:22+0300 ] LSP logging initiated
[ START ] 2021-07-26T09:26:43+0300 ] LSP logging initiated
[ START ] 2021-07-26T09:27:31+0300 ] LSP logging initiated
[ START ] 2021-07-26T09:49:45+0300 ] LSP logging initiated
[ START ] 2021-07-26T09:21:27+0300 ] LSP logging initiated
[ START ] 2021-07-26T09:51:30+0300 ] LSP logging initiated
[ START ] 2021-07-26T09:54:07+0300 ] LSP logging initiated
[ START ] 2021-07-26T10:04:24+0300 ] LSP logging initiated
[ START ] 2021-07-26T10:04:44+0300 ] LSP logging initiated
[ START ] 2021-07-26T09:57:19+0300 ] LSP logging initiated
[ START ] 2021-07-26T10:01:12+0300 ] LSP logging initiated
[ START ] 2021-07-26T10:15:53+0300 ] LSP logging initiated
[ START ] 2021-07-26T10:02:27+0300 ] LSP logging initiated
[ START ] 2021-07-26T10:11:14+0300 ] LSP logging initiated
[ START ] 2021-07-26T10:16:10+0300 ] LSP logging initiated
[ START ] 2021-07-27T07:50:14+0300 ] LSP logging initiated
[ START ] 2021-07-27T09:19:35+0300 ] LSP logging initiated
[ START ] 2021-07-27T09:42:55+0300 ] LSP logging initiated
[ START ] 2021-07-27T16:32:10+0300 ] LSP logging initiated
[ START ] 2021-07-28T17:07:07+0300 ] LSP logging initiated
[ START ] 2021-07-28T19:07:34+0300 ] LSP logging initiated
[ START ] 2021-07-28T19:11:29+0300 ] LSP logging initiated
[ START ] 2021-07-28T19:13:47+0300 ] LSP logging initiated
[ START ] 2021-07-28T19:14:23+0300 ] LSP logging initiated
[ START ] 2021-07-28T19:24:23+0300 ] LSP logging initiated
[ START ] 2021-07-29T12:34:34+0300 ] LSP logging initiated
[ START ] 2021-07-29T12:54:30+0300 ] LSP logging initiated
[ START ] 2021-07-29T12:55:23+0300 ] LSP logging initiated
[ START ] 2021-07-29T15:23:13+0300 ] LSP logging initiated
[ START ] 2021-07-30T13:35:43+0300 ] LSP logging initiated
[ START ] 2021-07-30T13:37:42+0300 ] LSP logging initiated
[ START ] 2021-07-30T15:49:25+0300 ] LSP logging initiated
[ START ] 2021-07-30T17:37:38+0300 ] LSP logging initiated
[ START ] 2021-07-30T21:44:24+0300 ] LSP logging initiated
[ START ] 2021-07-30T21:57:36+0300 ] LSP logging initiated
[ START ] 2021-07-30T22:09:21+0300 ] LSP logging initiated
[ START ] 2021-07-30T22:32:52+0300 ] LSP logging initiated
[ START ] 2021-07-31T12:49:21+0300 ] LSP logging initiated
[ START ] 2021-07-31T12:50:20+0300 ] LSP logging initiated
[ START ] 2021-07-31T12:50:38+0300 ] LSP logging initiated
[ START ] 2021-07-31T13:01:10+0300 ] LSP logging initiated
[ START ] 2021-07-31T13:01:13+0300 ] LSP logging initiated
[ START ] 2021-07-31T13:02:24+0300 ] LSP logging initiated
[ START ] 2021-07-31T13:01:37+0300 ] LSP logging initiated
[ START ] 2021-07-31T15:19:26+0300 ] LSP logging initiated
[ START ] 2021-07-31T14:19:38+0300 ] LSP logging initiated
[ START ] 2021-08-01T13:16:02+0300 ] LSP logging initiated
[ START ] 2021-08-01T16:37:27+0300 ] LSP logging initiated
[ START ] 2021-08-01T16:50:06+0300 ] LSP logging initiated
[ START ] 2021-08-02T15:34:55+0300 ] LSP logging initiated
[ START ] 2021-08-02T15:38:29+0300 ] LSP logging initiated
[ START ] 2021-08-02T15:40:30+0300 ] LSP logging initiated
[ START ] 2021-08-02T15:45:52+0300 ] LSP logging initiated
[ START ] 2021-08-02T15:46:55+0300 ] LSP logging initiated
[ START ] 2021-08-02T20:12:16+0300 ] LSP logging initiated
[ START ] 2021-08-03T15:11:30+0300 ] LSP logging initiated
[ START ] 2021-08-03T15:12:06+0300 ] LSP logging initiated
[ START ] 2021-08-03T15:06:56+0300 ] LSP logging initiated
[ START ] 2021-08-03T15:39:04+0300 ] LSP logging initiated
[ START ] 2021-08-03T15:58:08+0300 ] LSP logging initiated
[ START ] 2021-08-04T16:12:46+0300 ] LSP logging initiated
[ START ] 2021-08-04T21:06:07+0300 ] LSP logging initiated
[ START ] 2021-08-05T15:18:18+0300 ] LSP logging initiated
[ START ] 2021-08-06T18:47:15+0300 ] LSP logging initiated
[ START ] 2021-08-06T18:48:15+0300 ] LSP logging initiated
[ START ] 2021-08-06T18:41:37+0300 ] LSP logging initiated
[ START ] 2021-08-06T18:56:21+0300 ] LSP logging initiated
[ START ] 2021-08-06T19:35:53+0300 ] LSP logging initiated
[ START ] 2021-08-06T20:08:00+0300 ] LSP logging initiated
[ START ] 2021-08-06T20:08:15+0300 ] LSP logging initiated
[ START ] 2021-08-06T20:08:31+0300 ] LSP logging initiated
[ START ] 2021-08-06T19:29:54+0300 ] LSP logging initiated
[ START ] 2021-08-06T22:27:24+0300 ] LSP logging initiated
[ START ] 2021-08-07T00:56:32+0300 ] LSP logging initiated
[ START ] 2021-08-08T17:23:32+0300 ] LSP logging initiated
[ START ] 2021-08-08T19:44:32+0300 ] LSP logging initiated
[ START ] 2021-08-08T20:14:34+0300 ] LSP logging initiated
[ START ] 2021-08-08T20:15:48+0300 ] LSP logging initiated
[ START ] 2021-08-08T20:19:30+0300 ] LSP logging initiated
[ START ] 2021-08-08T21:11:30+0300 ] LSP logging initiated
[ START ] 2021-08-08T21:14:01+0300 ] LSP logging initiated
[ START ] 2021-08-08T21:15:19+0300 ] LSP logging initiated
[ START ] 2021-08-08T20:16:11+0300 ] LSP logging initiated
[ START ] 2021-08-08T19:44:37+0300 ] LSP logging initiated
[ START ] 2021-08-09T12:40:48+0300 ] LSP logging initiated
[ START ] 2021-08-09T12:40:54+0300 ] LSP logging initiated
[ START ] 2021-08-09T12:41:09+0300 ] LSP logging initiated
[ START ] 2021-08-09T12:41:46+0300 ] LSP logging initiated
[ START ] 2021-08-09T12:43:58+0300 ] LSP logging initiated
[ START ] 2021-08-09T12:54:28+0300 ] LSP logging initiated
[ START ] 2021-08-09T12:34:25+0300 ] LSP logging initiated
[ START ] 2021-08-09T20:59:09+0300 ] LSP logging initiated
[ START ] 2021-08-09T21:34:32+0300 ] LSP logging initiated
[ START ] 2021-08-09T21:04:30+0300 ] LSP logging initiated
[ START ] 2021-08-09T12:52:55+0300 ] LSP logging initiated
[ START ] 2021-08-10T17:20:35+0300 ] LSP logging initiated
[ START ] 2021-08-10T17:34:42+0300 ] LSP logging initiated
[ START ] 2021-08-10T17:44:52+0300 ] LSP logging initiated
[ START ] 2021-08-10T18:27:07+0300 ] LSP logging initiated
[ START ] 2021-08-10T18:59:52+0300 ] LSP logging initiated
[ START ] 2021-08-10T18:57:19+0300 ] LSP logging initiated
[ START ] 2021-08-10T22:12:21+0300 ] LSP logging initiated
[ START ] 2021-08-10T22:59:32+0300 ] LSP logging initiated
[ START ] 2021-08-10T22:58:05+0300 ] LSP logging initiated
[ START ] 2021-08-10T23:40:05+0300 ] LSP logging initiated
[ START ] 2021-08-11T02:46:06+0300 ] LSP logging initiated
[ START ] 2021-08-11T03:38:30+0300 ] LSP logging initiated
[ START ] 2021-08-11T03:39:33+0300 ] LSP logging initiated
[ START ] 2021-08-11T03:40:22+0300 ] LSP logging initiated
[ START ] 2021-08-11T03:41:29+0300 ] LSP logging initiated
[ START ] 2021-08-11T03:43:15+0300 ] LSP logging initiated
[ START ] 2021-08-11T03:45:55+0300 ] LSP logging initiated
[ START ] 2021-08-11T03:49:46+0300 ] LSP logging initiated
[ START ] 2021-08-11T03:50:48+0300 ] LSP logging initiated
[ START ] 2021-08-11T03:51:48+0300 ] LSP logging initiated
[ START ] 2021-08-11T03:53:55+0300 ] LSP logging initiated
[ START ] 2021-08-11T03:54:39+0300 ] LSP logging initiated
[ START ] 2021-08-11T03:55:51+0300 ] LSP logging initiated
[ START ] 2021-08-11T04:26:09+0300 ] LSP logging initiated
[ START ] 2021-08-11T04:20:20+0300 ] LSP logging initiated
[ START ] 2021-08-11T03:00:06+0300 ] LSP logging initiated
[ START ] 2021-08-11T05:30:46+0300 ] LSP logging initiated
[ START ] 2021-08-11T05:33:17+0300 ] LSP logging initiated
[ START ] 2021-08-11T05:34:35+0300 ] LSP logging initiated
[ START ] 2021-08-11T05:50:28+0300 ] LSP logging initiated
[ START ] 2021-08-11T05:56:41+0300 ] LSP logging initiated
[ START ] 2021-08-11T05:59:05+0300 ] LSP logging initiated
[ START ] 2021-08-11T16:50:38+0300 ] LSP logging initiated
[ START ] 2021-08-11T18:56:45+0300 ] LSP logging initiated
[ START ] 2021-08-11T19:06:19+0300 ] LSP logging initiated
[ START ] 2021-08-11T18:50:11+0300 ] LSP logging initiated
[ START ] 2021-08-11T19:54:25+0300 ] LSP logging initiated
[ START ] 2021-08-11T19:54:32+0300 ] LSP logging initiated
[ START ] 2021-08-11T20:21:52+0300 ] LSP logging initiated
[ START ] 2021-08-11T20:28:07+0300 ] LSP logging initiated
[ START ] 2021-08-11T20:24:10+0300 ] LSP logging initiated
[ START ] 2021-08-11T23:14:29+0300 ] LSP logging initiated
[ START ] 2021-08-12T00:00:10+0300 ] LSP logging initiated
[ START ] 2021-08-12T00:22:30+0300 ] LSP logging initiated
[ START ] 2021-08-12T00:53:26+0300 ] LSP logging initiated
[ START ] 2021-08-12T00:02:23+0300 ] LSP logging initiated
[ START ] 2021-08-12T00:55:34+0300 ] LSP logging initiated
[ START ] 2021-08-12T07:22:43+0300 ] LSP logging initiated
[ START ] 2021-08-12T07:22:53+0300 ] LSP logging initiated
[ START ] 2021-08-12T07:45:01+0300 ] LSP logging initiated
[ START ] 2021-08-12T08:37:34+0300 ] LSP logging initiated
[ START ] 2021-08-12T08:43:12+0300 ] LSP logging initiated
[ START ] 2021-08-12T09:13:07+0300 ] LSP logging initiated
[ START ] 2021-08-12T09:23:49+0300 ] LSP logging initiated
[ START ] 2021-08-12T08:33:41+0300 ] LSP logging initiated
[ START ] 2021-08-12T09:25:27+0300 ] LSP logging initiated
[ START ] 2021-08-13T01:14:11+0300 ] LSP logging initiated
[ START ] 2021-08-13T01:52:58+0300 ] LSP logging initiated
[ START ] 2021-08-13T01:55:58+0300 ] LSP logging initiated
[ START ] 2021-08-13T01:56:17+0300 ] LSP logging initiated
[ START ] 2021-08-13T01:58:13+0300 ] LSP logging initiated
[ START ] 2021-08-13T02:00:02+0300 ] LSP logging initiated
[ START ] 2021-08-13T02:05:19+0300 ] LSP logging initiated
[ START ] 2021-08-13T02:06:50+0300 ] LSP logging initiated
[ START ] 2021-08-13T02:11:46+0300 ] LSP logging initiated
[ START ] 2021-08-13T01:15:41+0300 ] LSP logging initiated
[ START ] 2021-08-13T02:16:47+0300 ] LSP logging initiated
[ START ] 2021-08-13T01:18:10+0300 ] LSP logging initiated
[ START ] 2021-08-13T18:14:21+0300 ] LSP logging initiated
[ START ] 2021-08-13T18:14:13+0300 ] LSP logging initiated
[ START ] 2021-08-13T18:20:10+0300 ] LSP logging initiated
[ START ] 2021-08-13T18:22:57+0300 ] LSP logging initiated
[ START ] 2021-08-13T18:23:54+0300 ] LSP logging initiated
[ START ] 2021-08-13T18:21:10+0300 ] LSP logging initiated
[ START ] 2021-08-13T18:25:52+0300 ] LSP logging initiated
[ START ] 2021-08-13T18:25:05+0300 ] LSP logging initiated
[ START ] 2021-08-13T19:49:55+0300 ] LSP logging initiated
[ START ] 2021-08-13T18:29:11+0300 ] LSP logging initiated
[ START ] 2021-08-13T18:26:55+0300 ] LSP logging initiated
[ START ] 2021-08-14T01:17:41+0300 ] LSP logging initiated
[ START ] 2021-08-15T13:03:32+0300 ] LSP logging initiated
[ START ] 2021-08-15T22:14:39+0300 ] LSP logging initiated
[ START ] 2021-08-15T22:27:20+0300 ] LSP logging initiated
[ START ] 2021-08-15T22:27:26+0300 ] LSP logging initiated
[ START ] 2021-08-15T22:27:54+0300 ] LSP logging initiated
[ START ] 2021-08-15T22:29:35+0300 ] LSP logging initiated
[ START ] 2021-08-15T23:18:04+0300 ] LSP logging initiated
[ START ] 2021-08-15T23:46:33+0300 ] LSP logging initiated
[ START ] 2021-08-15T23:47:20+0300 ] LSP logging initiated
[ START ] 2021-08-15T23:48:58+0300 ] LSP logging initiated
[ START ] 2021-08-15T23:57:27+0300 ] LSP logging initiated
[ START ] 2021-08-16T00:00:22+0300 ] LSP logging initiated
[ START ] 2021-08-16T00:01:06+0300 ] LSP logging initiated
[ START ] 2021-08-15T23:38:25+0300 ] LSP logging initiated
[ START ] 2021-08-16T00:12:31+0300 ] LSP logging initiated
[ START ] 2021-08-16T00:01:50+0300 ] LSP logging initiated
[ START ] 2021-08-16T08:43:35+0300 ] LSP logging initiated
[ START ] 2021-08-16T08:14:38+0300 ] LSP logging initiated
[ START ] 2021-08-16T10:21:28+0300 ] LSP logging initiated
[ START ] 2021-08-16T10:31:23+0300 ] LSP logging initiated
[ START ] 2021-08-16T10:39:22+0300 ] LSP logging initiated
[ START ] 2021-08-16T10:43:26+0300 ] LSP logging initiated
[ START ] 2021-08-16T10:51:20+0300 ] LSP logging initiated
[ START ] 2021-08-16T10:53:11+0300 ] LSP logging initiated
[ START ] 2021-08-16T10:32:05+0300 ] LSP logging initiated
[ START ] 2021-08-17T05:28:53+0300 ] LSP logging initiated
[ START ] 2021-08-17T05:15:47+0300 ] LSP logging initiated
[ START ] 2021-08-17T05:29:52+0300 ] LSP logging initiated
[ START ] 2021-08-17T05:30:05+0300 ] LSP logging initiated
[ START ] 2021-08-17T05:29:56+0300 ] LSP logging initiated
[ START ] 2021-08-17T13:53:22+0300 ] LSP logging initiated
[ START ] 2021-08-17T15:04:54+0300 ] LSP logging initiated
[ START ] 2021-08-17T15:12:22+0300 ] LSP logging initiated
[ START ] 2021-08-17T20:34:25+0300 ] LSP logging initiated
[ START ] 2021-08-17T23:57:52+0300 ] LSP logging initiated
[ START ] 2021-08-18T01:10:00+0300 ] LSP logging initiated
[ START ] 2021-08-18T02:20:30+0300 ] LSP logging initiated
[ START ] 2021-08-18T02:19:55+0300 ] LSP logging initiated
[ START ] 2021-08-18T08:26:24+0300 ] LSP logging initiated
[ START ] 2021-08-18T08:26:53+0300 ] LSP logging initiated
[ START ] 2021-08-18T08:26:56+0300 ] LSP logging initiated
[ START ] 2021-08-18T09:20:36+0300 ] LSP logging initiated
[ START ] 2021-08-18T09:21:21+0300 ] LSP logging initiated
[ START ] 2021-08-18T09:47:16+0300 ] LSP logging initiated
[ START ] 2021-08-18T09:47:33+0300 ] LSP logging initiated
[ START ] 2021-08-18T09:27:08+0300 ] LSP logging initiated
[ START ] 2021-08-18T09:48:15+0300 ] LSP logging initiated
[ START ] 2021-08-18T14:20:07+0300 ] LSP logging initiated
[ START ] 2021-08-18T14:21:24+0300 ] LSP logging initiated
[ START ] 2021-08-18T15:06:36+0300 ] LSP logging initiated
[ START ] 2021-08-18T15:14:31+0300 ] LSP logging initiated
[ START ] 2021-08-18T16:24:58+0300 ] LSP logging initiated
[ START ] 2021-08-18T22:21:10+0300 ] LSP logging initiated
[ START ] 2021-08-18T22:21:51+0300 ] LSP logging initiated
[ START ] 2021-08-18T22:23:26+0300 ] LSP logging initiated
[ START ] 2021-08-18T23:50:34+0300 ] LSP logging initiated
[ START ] 2021-08-18T23:10:59+0300 ] LSP logging initiated
[ START ] 2021-08-19T00:17:14+0300 ] LSP logging initiated
[ START ] 2021-08-19T01:17:31+0300 ] LSP logging initiated
[ START ] 2021-08-19T01:18:46+0300 ] LSP logging initiated
[ START ] 2021-08-19T01:19:36+0300 ] LSP logging initiated
[ START ] 2021-08-19T01:19:43+0300 ] LSP logging initiated
[ START ] 2021-08-19T01:19:49+0300 ] LSP logging initiated
[ START ] 2021-08-19T08:07:29+0300 ] LSP logging initiated
[ START ] 2021-08-20T01:31:43+0300 ] LSP logging initiated
[ START ] 2021-08-20T01:25:02+0300 ] LSP logging initiated
[ START ] 2021-08-20T02:03:46+0300 ] LSP logging initiated
[ START ] 2021-08-20T03:02:01+0300 ] LSP logging initiated
[ START ] 2021-08-20T05:18:55+0300 ] LSP logging initiated
[ START ] 2021-08-20T05:29:27+0300 ] LSP logging initiated
[ START ] 2021-08-20T12:45:26+0300 ] LSP logging initiated
[ START ] 2021-08-21T06:13:26+0300 ] LSP logging initiated
[ START ] 2021-08-21T06:18:28+0300 ] LSP logging initiated
[ START ] 2021-08-21T06:35:44+0300 ] LSP logging initiated
[ START ] 2021-08-21T07:58:28+0300 ] LSP logging initiated
[ START ] 2021-08-21T07:58:31+0300 ] LSP logging initiated
[ START ] 2021-08-21T07:46:10+0300 ] LSP logging initiated
[ START ] 2021-08-21T08:07:36+0300 ] LSP logging initiated
[ START ] 2021-08-22T11:48:19+0300 ] LSP logging initiated
[ START ] 2021-08-22T12:17:29+0300 ] LSP logging initiated
[ START ] 2021-08-22T13:15:55+0300 ] LSP logging initiated
[ START ] 2021-08-23T06:38:03+0300 ] LSP logging initiated
[ START ] 2021-08-23T07:31:22+0300 ] LSP logging initiated
[ START ] 2021-08-23T11:46:07+0300 ] LSP logging initiated
[ START ] 2021-08-23T11:46:59+0300 ] LSP logging initiated
[ START ] 2021-08-26T11:08:29+0300 ] LSP logging initiated
[ START ] 2021-08-26T11:12:52+0300 ] LSP logging initiated
[ START ] 2021-08-26T14:02:13+0300 ] LSP logging initiated
[ START ] 2021-08-26T14:06:57+0300 ] LSP logging initiated
[ START ] 2021-08-27T19:37:32+0300 ] LSP logging initiated
[ START ] 2021-08-28T11:03:41+0300 ] LSP logging initiated
[ START ] 2021-08-31T16:09:02+0300 ] LSP logging initiated
[ START ] 2021-08-31T16:09:09+0300 ] LSP logging initiated
[ START ] 2021-08-31T16:11:09+0300 ] LSP logging initiated
[ START ] 2021-08-31T16:13:32+0300 ] LSP logging initiated
[ START ] 2021-09-02T22:03:22+0300 ] LSP logging initiated
[ START ] 2021-09-02T22:24:34+0300 ] LSP logging initiated
[ START ] 2021-09-03T14:40:48+0300 ] LSP logging initiated
[ START ] 2021-09-03T19:42:27+0300 ] LSP logging initiated
[ START ] 2021-09-05T14:06:29+0300 ] LSP logging initiated
[ START ] 2021-09-05T14:07:51+0300 ] LSP logging initiated
[ START ] 2021-09-05T14:10:43+0300 ] LSP logging initiated
[ START ] 2021-09-05T14:18:30+0300 ] LSP logging initiated
[ START ] 2021-09-05T14:26:06+0300 ] LSP logging initiated
[ START ] 2021-09-05T15:59:15+0300 ] LSP logging initiated
[ START ] 2021-09-05T15:43:29+0300 ] LSP logging initiated
[ START ] 2021-09-05T17:08:16+0300 ] LSP logging initiated
[ START ] 2021-09-05T23:46:11+0300 ] LSP logging initiated
[ START ] 2021-09-06T00:16:01+0300 ] LSP logging initiated
[ START ] 2021-09-06T01:22:22+0300 ] LSP logging initiated
[ START ] 2021-09-06T13:30:21+0300 ] LSP logging initiated
[ START ] 2021-09-06T13:28:42+0300 ] LSP logging initiated
[ START ] 2021-09-06T14:27:36+0300 ] LSP logging initiated
[ START ] 2021-09-07T00:04:21+0300 ] LSP logging initiated
[ START ] 2021-09-09T17:46:42+0300 ] LSP logging initiated
[ START ] 2021-09-09T22:41:02+0300 ] LSP logging initiated
[ START ] 2021-09-10T16:17:52+0300 ] LSP logging initiated
[ START ] 2021-09-10T16:13:15+0300 ] LSP logging initiated
[ START ] 2021-09-10T22:19:14+0300 ] LSP logging initiated
[ START ] 2021-09-11T12:19:56+0300 ] LSP logging initiated
[ START ] 2021-09-11T12:14:29+0300 ] LSP logging initiated
[ START ] 2021-09-11T12:24:19+0300 ] LSP logging initiated
[ START ] 2021-09-11T12:21:12+0300 ] LSP logging initiated
[ START ] 2021-09-11T12:09:21+0300 ] LSP logging initiated
[ START ] 2021-09-11T14:34:22+0300 ] LSP logging initiated
[ START ] 2021-09-11T14:53:24+0300 ] LSP logging initiated
[ START ] 2021-09-11T14:54:49+0300 ] LSP logging initiated
[ START ] 2021-09-11T15:09:39+0300 ] LSP logging initiated
[ START ] 2021-09-11T15:01:23+0300 ] LSP logging initiated
[ START ] 2021-09-11T18:43:07+0300 ] LSP logging initiated
[ START ] 2021-09-12T15:06:13+0300 ] LSP logging initiated
[ START ] 2021-09-12T15:08:09+0300 ] LSP logging initiated
[ START ] 2021-09-12T16:13:41+0300 ] LSP logging initiated
[ START ] 2021-09-12T16:14:14+0300 ] LSP logging initiated
[ START ] 2021-09-12T16:15:01+0300 ] LSP logging initiated
[ START ] 2021-09-13T01:21:07+0300 ] LSP logging initiated
[ START ] 2021-09-13T14:56:59+0300 ] LSP logging initiated
[ START ] 2021-09-14T15:53:22+0300 ] LSP logging initiated
[ START ] 2021-09-14T17:03:45+0300 ] LSP logging initiated
[ START ] 2021-09-14T17:12:55+0300 ] LSP logging initiated
[ START ] 2021-09-14T17:04:58+0300 ] LSP logging initiated
[ START ] 2021-09-16T11:42:39+0300 ] LSP logging initiated
[ START ] 2021-09-16T11:52:14+0300 ] LSP logging initiated
[ START ] 2021-09-16T12:05:53+0300 ] LSP logging initiated
[ START ] 2021-09-16T18:56:08+0300 ] LSP logging initiated
[ START ] 2021-09-16T19:05:19+0300 ] LSP logging initiated
[ START ] 2021-09-16T19:13:02+0300 ] LSP logging initiated
[ START ] 2021-09-18T01:10:05+0300 ] LSP logging initiated
[ START ] 2021-09-19T12:07:37+0300 ] LSP logging initiated
[ START ] 2021-09-19T12:23:18+0300 ] LSP logging initiated
[ START ] 2021-09-22T09:57:20+0300 ] LSP logging initiated
[ START ] 2021-09-22T10:07:55+0300 ] LSP logging initiated
[ START ] 2021-09-22T17:29:38+0300 ] LSP logging initiated
[ START ] 2021-09-22T17:29:41+0300 ] LSP logging initiated
[ START ] 2021-09-22T21:14:35+0300 ] LSP logging initiated
[ START ] 2021-09-22T21:14:46+0300 ] LSP logging initiated
[ START ] 2021-09-22T21:17:35+0300 ] LSP logging initiated
[ START ] 2021-09-22T21:17:18+0300 ] LSP logging initiated
[ START ] 2021-09-22T21:34:54+0300 ] LSP logging initiated
[ START ] 2021-09-23T16:18:56+0300 ] LSP logging initiated
[ START ] 2021-09-23T16:16:50+0300 ] LSP logging initiated
[ START ] 2021-09-23T16:44:31+0300 ] LSP logging initiated
[ START ] 2021-09-23T16:49:03+0300 ] LSP logging initiated
[ START ] 2021-09-23T20:50:28+0300 ] LSP logging initiated
[ START ] 2021-09-23T20:55:03+0300 ] LSP logging initiated
[ START ] 2021-09-23T20:55:51+0300 ] LSP logging initiated
[ START ] 2021-09-23T20:58:34+0300 ] LSP logging initiated
[ START ] 2021-09-24T23:06:21+0300 ] LSP logging initiated
[ START ] 2021-09-24T23:06:44+0300 ] LSP logging initiated
[ START ] 2021-09-24T23:07:01+0300 ] LSP logging initiated
[ START ] 2021-09-25T15:05:37+0300 ] LSP logging initiated
[ START ] 2021-09-26T22:47:33+0300 ] LSP logging initiated
[ START ] 2021-09-26T22:48:16+0300 ] LSP logging initiated
[ START ] 2021-09-26T22:36:49+0300 ] LSP logging initiated
[ START ] 2021-09-26T23:24:28+0300 ] LSP logging initiated
[ START ] 2021-09-26T22:48:40+0300 ] LSP logging initiated
[ START ] 2021-09-27T14:00:21+0300 ] LSP logging initiated
[ START ] 2021-09-27T14:00:25+0300 ] LSP logging initiated
[ START ] 2021-09-27T13:53:35+0300 ] LSP logging initiated
[ START ] 2021-09-27T14:42:15+0300 ] LSP logging initiated
[ START ] 2021-09-27T15:28:54+0300 ] LSP logging initiated
[ START ] 2021-09-27T20:57:31+0300 ] LSP logging initiated
[ START ] 2021-09-27T21:17:21+0300 ] LSP logging initiated
[ START ] 2021-09-27T21:18:55+0300 ] LSP logging initiated
[START][2021-09-27 22:00:27] LSP logging initiated
[START][2021-09-28 13:55:21] LSP logging initiated
[START][2021-09-28 13:55:27] LSP logging initiated
[START][2021-09-28 15:52:56] LSP logging initiated
[START][2021-09-28 15:54:30] LSP logging initiated
[START][2021-09-28 15:54:45] LSP logging initiated
[START][2021-09-28 15:54:56] LSP logging initiated
[START][2021-09-28 16:06:23] LSP logging initiated
[START][2021-09-28 16:06:44] LSP logging initiated
[START][2021-09-28 20:47:00] LSP logging initiated
[START][2021-09-28 21:18:32] LSP logging initiated
[START][2021-09-29 11:48:09] LSP logging initiated
[START][2021-09-29 12:27:20] LSP logging initiated
[START][2021-10-01 14:43:25] LSP logging initiated
[START][2021-10-01 16:26:58] LSP logging initiated
[START][2021-10-01 18:33:16] LSP logging initiated
[START][2021-10-01 18:37:05] LSP logging initiated
[START][2021-10-01 18:47:02] LSP logging initiated
[START][2021-10-01 18:50:17] LSP logging initiated
[START][2021-10-01 19:36:54] LSP logging initiated
[START][2021-10-01 20:00:39] LSP logging initiated
[START][2021-10-01 19:54:45] LSP logging initiated
[START][2021-10-02 13:46:48] LSP logging initiated
[START][2021-10-02 13:53:49] LSP logging initiated
[START][2021-10-02 13:54:40] LSP logging initiated
[START][2021-10-02 13:47:28] LSP logging initiated
[START][2021-10-02 16:16:01] LSP logging initiated
[START][2021-10-03 14:00:57] LSP logging initiated
[START][2021-10-03 14:01:53] LSP logging initiated
[START][2021-10-03 14:59:29] LSP logging initiated
[START][2021-10-03 14:56:59] LSP logging initiated
[START][2021-10-05 17:57:16] LSP logging initiated
[START][2021-10-05 20:07:58] LSP logging initiated
[START][2021-10-05 20:26:53] LSP logging initiated
[START][2021-10-05 20:06:48] LSP logging initiated
[START][2021-10-05 20:35:04] LSP logging initiated
[START][2021-10-05 20:11:57] LSP logging initiated
[START][2021-10-08 15:58:11] LSP logging initiated
[START][2021-10-08 16:22:24] LSP logging initiated
[START][2021-10-08 16:50:43] LSP logging initiated
[START][2021-10-09 12:00:36] LSP logging initiated
[START][2021-10-09 12:48:59] LSP logging initiated
[START][2021-10-09 12:57:18] LSP logging initiated
[START][2021-10-09 16:38:46] LSP logging initiated
[START][2021-10-09 16:37:59] LSP logging initiated
[START][2021-10-09 16:39:18] LSP logging initiated
[START][2021-10-09 16:47:30] LSP logging initiated
[START][2021-10-09 16:54:23] LSP logging initiated
[START][2021-10-09 16:51:17] LSP logging initiated
[START][2021-10-09 17:01:00] LSP logging initiated
[START][2021-10-09 16:55:12] LSP logging initiated
[START][2021-10-11 15:06:34] LSP logging initiated
[START][2021-10-11 15:09:43] LSP logging initiated
[START][2021-10-11 15:12:49] LSP logging initiated
[START][2021-10-11 15:16:51] LSP logging initiated
[START][2021-10-11 15:26:02] LSP logging initiated
[START][2021-10-11 15:00:43] LSP logging initiated
[START][2021-10-11 15:32:05] LSP logging initiated
[START][2021-10-11 20:38:43] LSP logging initiated
[START][2021-10-11 21:28:03] LSP logging initiated
[START][2021-10-11 22:12:44] LSP logging initiated
[START][2021-10-11 22:06:05] LSP logging initiated
[START][2021-10-11 22:14:04] LSP logging initiated
[START][2021-10-12 14:41:07] LSP logging initiated
[START][2021-10-13 11:55:14] LSP logging initiated
[START][2021-10-13 11:56:58] LSP logging initiated
[START][2021-10-13 12:24:29] LSP logging initiated
[START][2021-10-13 12:24:55] LSP logging initiated
[START][2021-10-13 12:31:19] LSP logging initiated
[START][2021-10-13 12:32:40] LSP logging initiated
[START][2021-10-13 12:25:00] LSP logging initiated
[START][2021-10-13 12:38:04] LSP logging initiated
[START][2021-10-13 12:38:08] LSP logging initiated
[START][2021-10-13 12:38:11] LSP logging initiated
[START][2021-10-13 12:38:16] LSP logging initiated
[START][2021-10-13 12:39:12] LSP logging initiated
[START][2021-10-13 12:39:28] LSP logging initiated
[START][2021-10-13 12:40:19] LSP logging initiated
[START][2021-10-13 12:38:20] LSP logging initiated
[START][2021-10-13 12:19:18] LSP logging initiated
[START][2021-10-13 12:40:36] LSP logging initiated
[START][2021-10-13 13:15:50] LSP logging initiated
[START][2021-10-13 13:59:07] LSP logging initiated
[START][2021-10-13 14:03:02] LSP logging initiated
[START][2021-10-13 14:04:42] LSP logging initiated
[START][2021-10-13 13:37:07] LSP logging initiated
[START][2021-10-13 14:17:56] LSP logging initiated
[START][2021-10-13 14:53:58] LSP logging initiated
[START][2021-10-14 08:34:00] LSP logging initiated
[START][2021-10-14 08:41:24] LSP logging initiated
[START][2021-10-14 11:04:46] LSP logging initiated
[START][2021-10-14 11:06:20] LSP logging initiated
[START][2021-10-14 11:10:21] LSP logging initiated
[START][2021-10-14 11:12:03] LSP logging initiated
[START][2021-10-14 11:13:21] LSP logging initiated
[START][2021-10-14 11:15:57] LSP logging initiated
[START][2021-10-14 11:16:39] LSP logging initiated
[START][2021-10-14 11:17:32] LSP logging initiated
[START][2021-10-14 11:19:20] LSP logging initiated
[START][2021-10-14 11:20:16] LSP logging initiated
[START][2021-10-14 11:20:23] LSP logging initiated
[START][2021-10-14 11:23:29] LSP logging initiated
[START][2021-10-14 15:12:53] LSP logging initiated
[START][2021-10-14 13:43:13] LSP logging initiated
[START][2021-10-15 00:37:30] LSP logging initiated
[START][2021-10-15 15:54:27] LSP logging initiated
[START][2021-10-15 16:02:05] LSP logging initiated
[START][2021-10-15 16:25:04] LSP logging initiated
[START][2021-10-15 16:47:06] LSP logging initiated
[START][2021-10-15 16:47:14] LSP logging initiated
[START][2021-10-15 16:47:48] LSP logging initiated
[START][2021-10-15 16:48:57] LSP logging initiated
[START][2021-10-15 16:52:44] LSP logging initiated
[START][2021-10-15 16:33:03] LSP logging initiated
[START][2021-10-16 14:29:31] LSP logging initiated
[START][2021-10-16 15:41:36] LSP logging initiated
[START][2021-10-16 16:12:41] LSP logging initiated
[START][2021-10-16 16:12:59] LSP logging initiated
[START][2021-10-16 16:16:43] LSP logging initiated
[START][2021-10-16 16:31:55] LSP logging initiated
[START][2021-10-16 18:08:10] LSP logging initiated
[START][2021-10-17 01:11:54] LSP logging initiated
[START][2021-10-17 03:17:44] LSP logging initiated
[START][2021-10-17 03:19:24] LSP logging initiated
[START][2021-10-17 15:48:06] LSP logging initiated
[START][2021-10-17 15:49:03] LSP logging initiated
[START][2021-10-17 15:22:20] LSP logging initiated
[START][2021-10-17 16:12:56] LSP logging initiated
[START][2021-10-18 13:09:52] LSP logging initiated
[START][2021-10-18 13:16:25] LSP logging initiated
[START][2021-10-18 13:17:27] LSP logging initiated
[START][2021-10-18 13:18:22] LSP logging initiated
[START][2021-10-18 13:19:02] LSP logging initiated
[START][2021-10-19 02:15:04] LSP logging initiated
[START][2021-10-19 02:15:54] LSP logging initiated
[START][2021-10-19 02:18:59] LSP logging initiated
[START][2021-10-19 02:05:31] LSP logging initiated
[START][2021-10-19 02:41:43] LSP logging initiated
[START][2021-10-19 02:51:00] LSP logging initiated
[START][2021-10-19 15:33:09] LSP logging initiated
[START][2021-10-19 15:37:44] LSP logging initiated
[START][2021-10-19 15:35:57] LSP logging initiated
[START][2021-10-19 15:33:18] LSP logging initiated
[START][2021-10-20 16:37:35] LSP logging initiated
[START][2021-10-20 16:45:02] LSP logging initiated
[START][2021-10-20 17:58:33] LSP logging initiated
[START][2021-10-20 21:33:39] LSP logging initiated
[START][2021-10-20 21:39:26] LSP logging initiated
[START][2021-10-21 12:06:50] LSP logging initiated
[START][2021-10-21 12:08:22] LSP logging initiated
[START][2021-10-21 12:03:01] LSP logging initiated
[START][2021-10-21 12:15:34] LSP logging initiated
[START][2021-10-21 12:10:51] LSP logging initiated
[START][2021-10-21 12:26:54] LSP logging initiated
[START][2021-10-21 13:10:51] LSP logging initiated
[START][2021-10-21 13:10:56] LSP logging initiated
[START][2021-10-21 13:54:34] LSP logging initiated
[START][2021-10-21 16:28:02] LSP logging initiated
[START][2021-10-21 16:28:26] LSP logging initiated
[START][2021-10-21 16:46:25] LSP logging initiated
[START][2021-10-21 22:01:15] LSP logging initiated
[START][2021-10-21 22:34:26] LSP logging initiated
[START][2021-10-22 21:42:40] LSP logging initiated
[START][2021-10-22 21:48:09] LSP logging initiated
[START][2021-10-23 02:11:52] LSP logging initiated
[START][2021-10-23 02:12:49] LSP logging initiated
[START][2021-10-23 02:16:03] LSP logging initiated
[START][2021-10-23 02:17:34] LSP logging initiated
[START][2021-10-23 01:26:55] LSP logging initiated
[START][2021-10-23 14:57:20] LSP logging initiated
[START][2021-10-23 15:02:29] LSP logging initiated
[START][2021-10-23 15:38:30] LSP logging initiated
[START][2021-10-23 14:52:11] LSP logging initiated
[START][2021-10-23 16:24:42] LSP logging initiated
[START][2021-10-23 17:27:49] LSP logging initiated
[START][2021-10-23 17:29:08] LSP logging initiated
[START][2021-10-23 17:57:50] LSP logging initiated
[START][2021-10-23 17:34:13] LSP logging initiated
[START][2021-10-23 18:14:01] LSP logging initiated
[START][2021-10-23 18:14:41] LSP logging initiated
[START][2021-10-23 18:14:23] LSP logging initiated
[START][2021-10-23 18:48:38] LSP logging initiated
[START][2021-10-23 18:49:04] LSP logging initiated
[START][2021-10-23 20:11:45] LSP logging initiated
[START][2021-10-23 20:12:45] LSP logging initiated
[START][2021-10-23 20:13:01] LSP logging initiated
[START][2021-10-23 20:19:37] LSP logging initiated
[START][2021-10-23 20:14:26] LSP logging initiated
[START][2021-10-23 20:29:36] LSP logging initiated
[START][2021-10-23 20:32:15] LSP logging initiated
[START][2021-10-23 20:35:36] LSP logging initiated
[START][2021-10-23 20:36:31] LSP logging initiated
[START][2021-10-23 20:38:42] LSP logging initiated
[START][2021-10-23 20:39:11] LSP logging initiated
[START][2021-10-23 22:17:39] LSP logging initiated
[START][2021-10-23 22:23:04] LSP logging initiated
[START][2021-10-23 22:23:38] LSP logging initiated
[START][2021-10-23 22:19:46] LSP logging initiated
[START][2021-10-23 22:36:43] LSP logging initiated
[START][2021-10-23 22:24:15] LSP logging initiated
[START][2021-10-24 15:42:19] LSP logging initiated
[START][2021-10-24 16:38:26] LSP logging initiated
[START][2021-10-26 19:07:33] LSP logging initiated
[START][2021-10-26 19:05:22] LSP logging initiated
[START][2021-10-26 21:59:57] LSP logging initiated
[START][2021-10-26 22:18:18] LSP logging initiated
[START][2021-10-26 22:22:32] LSP logging initiated
[START][2021-10-26 22:24:04] LSP logging initiated
[START][2021-10-27 00:44:54] LSP logging initiated
[START][2021-10-27 14:15:51] LSP logging initiated
[START][2021-10-27 14:32:55] LSP logging initiated
[START][2021-10-27 15:38:03] LSP logging initiated
[START][2021-10-27 16:28:43] LSP logging initiated
[START][2021-10-27 20:31:07] LSP logging initiated
[START][2021-10-27 20:35:18] LSP logging initiated
[START][2021-10-27 20:36:13] LSP logging initiated
[START][2021-10-27 20:39:23] LSP logging initiated
[START][2021-10-28 22:23:29] LSP logging initiated
[START][2021-10-28 22:29:32] LSP logging initiated
[START][2021-10-28 23:23:50] LSP logging initiated
[START][2021-10-28 23:31:11] LSP logging initiated
[START][2021-10-29 00:33:44] LSP logging initiated
[START][2021-10-29 11:33:48] LSP logging initiated
[START][2021-10-29 11:51:45] LSP logging initiated
[START][2021-10-31 03:27:31] LSP logging initiated
[START][2021-10-31 04:40:12] LSP logging initiated
[START][2021-10-31 04:39:23] LSP logging initiated
[START][2021-11-02 19:34:57] LSP logging initiated
[START][2021-11-02 19:45:05] LSP logging initiated
[START][2021-11-02 19:47:25] LSP logging initiated
[START][2021-11-02 19:47:46] LSP logging initiated
[START][2021-11-02 19:49:09] LSP logging initiated
[START][2021-11-02 19:50:06] LSP logging initiated
[START][2021-11-02 19:50:33] LSP logging initiated
[START][2021-11-02 19:50:58] LSP logging initiated
[START][2021-11-02 19:51:33] LSP logging initiated
[START][2021-11-02 20:18:39] LSP logging initiated
[START][2021-11-02 20:18:57] LSP logging initiated
[START][2021-11-02 20:45:15] LSP logging initiated
[START][2021-11-02 20:47:31] LSP logging initiated
[START][2021-11-03 00:24:39] LSP logging initiated
[START][2021-11-03 12:06:18] LSP logging initiated
[START][2021-11-03 12:21:40] LSP logging initiated
[START][2021-11-03 12:33:25] LSP logging initiated
[START][2021-11-03 12:48:08] LSP logging initiated
[START][2021-11-03 13:15:02] LSP logging initiated
[START][2021-11-03 13:35:11] LSP logging initiated
[START][2021-11-03 14:44:42] LSP logging initiated
[START][2021-11-03 14:55:21] LSP logging initiated
[START][2021-11-03 14:55:31] LSP logging initiated
[START][2021-11-03 14:56:36] LSP logging initiated
[START][2021-11-03 14:56:40] LSP logging initiated
[START][2021-11-03 16:11:55] LSP logging initiated
[START][2021-11-03 16:17:09] LSP logging initiated
[START][2021-11-03 16:22:38] LSP logging initiated
[START][2021-11-03 16:23:24] LSP logging initiated
[START][2021-11-03 20:46:03] LSP logging initiated
[START][2021-11-03 21:58:53] LSP logging initiated
[START][2021-11-03 22:02:37] LSP logging initiated
[START][2021-11-04 15:46:09] LSP logging initiated
[START][2021-11-04 15:50:39] LSP logging initiated
[START][2021-11-04 15:55:47] LSP logging initiated
[START][2021-11-04 16:36:19] LSP logging initiated
[START][2021-11-04 16:38:13] LSP logging initiated
[START][2021-11-04 19:09:22] LSP logging initiated
[START][2021-11-04 19:09:30] LSP logging initiated
[START][2021-11-04 16:36:55] LSP logging initiated
[START][2021-11-04 19:55:29] LSP logging initiated
[START][2021-11-04 20:24:51] LSP logging initiated
[START][2021-11-04 21:11:14] LSP logging initiated
[START][2021-11-04 19:55:19] LSP logging initiated
[START][2021-11-04 21:14:38] LSP logging initiated
[START][2021-11-04 22:17:57] LSP logging initiated
[START][2021-11-04 22:18:23] LSP logging initiated
[START][2021-11-04 22:27:07] LSP logging initiated
[START][2021-11-04 23:04:57] LSP logging initiated
[START][2021-11-04 23:20:13] LSP logging initiated
[START][2021-11-04 23:25:36] LSP logging initiated
[START][2021-11-04 22:20:00] LSP logging initiated
[START][2021-11-04 23:28:29] LSP logging initiated
[START][2021-11-05 01:40:31] LSP logging initiated
[START][2021-11-05 01:41:47] LSP logging initiated
[START][2021-11-05 01:42:22] LSP logging initiated
[START][2021-11-05 01:42:37] LSP logging initiated
[START][2021-11-05 01:32:00] LSP logging initiated
[START][2021-11-05 01:43:37] LSP logging initiated
[START][2021-11-05 01:43:58] LSP logging initiated
[START][2021-11-05 01:44:17] LSP logging initiated
[START][2021-11-05 01:44:30] LSP logging initiated
[START][2021-11-05 01:44:46] LSP logging initiated
[START][2021-11-05 01:45:29] LSP logging initiated
[START][2021-11-05 01:45:41] LSP logging initiated
[START][2021-11-05 01:46:37] LSP logging initiated
[START][2021-11-05 01:46:57] LSP logging initiated
[START][2021-11-05 01:47:55] LSP logging initiated
[START][2021-11-05 02:34:54] LSP logging initiated
[START][2021-11-05 02:23:00] LSP logging initiated
[START][2021-11-05 02:23:12] LSP logging initiated
[START][2021-11-05 02:39:59] LSP logging initiated
[START][2021-11-05 14:59:14] LSP logging initiated
[START][2021-11-05 15:15:38] LSP logging initiated
[START][2021-11-05 15:18:24] LSP logging initiated
[START][2021-11-05 15:18:20] LSP logging initiated
[START][2021-11-05 18:23:53] LSP logging initiated
[START][2021-11-05 18:24:11] LSP logging initiated
[START][2021-11-05 18:24:46] LSP logging initiated
[START][2021-11-05 18:29:35] LSP logging initiated
[START][2021-11-06 13:31:06] LSP logging initiated
[START][2021-11-06 19:09:06] LSP logging initiated
[START][2021-11-07 01:07:41] LSP logging initiated
[START][2021-11-07 16:16:25] LSP logging initiated
[START][2021-11-07 16:34:28] LSP logging initiated
[START][2021-11-07 16:50:28] LSP logging initiated
[START][2021-11-07 16:17:48] LSP logging initiated
[START][2021-11-07 17:36:17] LSP logging initiated
[START][2021-11-07 17:40:05] LSP logging initiated
[START][2021-11-07 18:47:07] LSP logging initiated
[START][2021-11-07 18:47:16] LSP logging initiated
[START][2021-11-07 18:47:59] LSP logging initiated
[START][2021-11-07 20:23:23] LSP logging initiated
[START][2021-11-07 23:17:23] LSP logging initiated
[START][2021-11-07 23:18:02] LSP logging initiated
[START][2021-11-07 23:22:43] LSP logging initiated
[START][2021-11-07 23:26:39] LSP logging initiated
[START][2021-11-07 23:43:59] LSP logging initiated
[START][2021-11-07 23:44:19] LSP logging initiated
[START][2021-11-07 23:45:36] LSP logging initiated
[START][2021-11-07 23:46:03] LSP logging initiated
[START][2021-11-07 23:46:38] LSP logging initiated
[START][2021-11-07 23:47:09] LSP logging initiated
[START][2021-11-07 23:47:15] LSP logging initiated
[START][2021-11-07 23:54:36] LSP logging initiated
[START][2021-11-07 23:56:57] LSP logging initiated
[START][2021-11-07 23:58:30] LSP logging initiated
[START][2021-11-08 00:00:20] LSP logging initiated
[START][2021-11-08 00:13:45] LSP logging initiated
[START][2021-11-08 00:29:58] LSP logging initiated
[START][2021-11-08 15:10:38] LSP logging initiated
[START][2021-11-08 14:52:38] LSP logging initiated
[START][2021-11-09 00:44:42] LSP logging initiated
[START][2021-11-09 01:02:23] LSP logging initiated
[START][2021-11-09 07:49:43] LSP logging initiated
[START][2021-11-09 11:15:15] LSP logging initiated
[START][2021-11-09 11:12:54] LSP logging initiated
[START][2021-11-09 11:19:10] LSP logging initiated
[START][2021-11-09 17:28:17] LSP logging initiated
[START][2021-11-09 17:32:39] LSP logging initiated
[START][2021-11-09 19:26:57] LSP logging initiated
[START][2021-11-09 17:33:13] LSP logging initiated
[START][2021-11-09 22:54:55] LSP logging initiated
[START][2021-11-09 23:00:58] LSP logging initiated
[START][2021-11-10 00:14:05] LSP logging initiated
[START][2021-11-10 16:44:06] LSP logging initiated
[START][2021-11-10 17:54:23] LSP logging initiated
[START][2021-11-10 17:25:19] LSP logging initiated
[START][2021-11-10 19:27:45] LSP logging initiated
[START][2021-11-11 18:27:38] LSP logging initiated
[START][2021-11-11 21:59:52] LSP logging initiated
[START][2021-11-11 21:59:03] LSP logging initiated
[START][2021-11-13 00:17:05] LSP logging initiated
[START][2021-11-12 23:40:21] LSP logging initiated
[START][2021-11-13 00:26:37] LSP logging initiated
[START][2021-11-13 00:00:09] LSP logging initiated
[START][2021-11-12 23:40:29] LSP logging initiated
[START][2021-11-13 16:42:18] LSP logging initiated
[START][2021-11-13 16:40:55] LSP logging initiated
[START][2021-11-13 20:09:28] LSP logging initiated
[START][2021-11-13 20:13:04] LSP logging initiated
[START][2021-11-13 20:06:08] LSP logging initiated
[START][2021-11-13 20:13:23] LSP logging initiated
[START][2021-11-13 20:17:09] LSP logging initiated
[START][2021-11-13 20:13:13] LSP logging initiated
[START][2021-11-13 20:17:37] LSP logging initiated
[START][2021-11-15 14:09:57] LSP logging initiated
[START][2021-11-15 17:54:16] LSP logging initiated
[START][2021-11-15 18:00:53] LSP logging initiated
[START][2021-11-15 18:03:36] LSP logging initiated
[START][2021-11-15 18:08:51] LSP logging initiated
[START][2021-11-15 18:11:26] LSP logging initiated
[START][2021-11-15 18:12:21] LSP logging initiated
[START][2021-11-15 18:13:04] LSP logging initiated
[START][2021-11-15 18:27:04] LSP logging initiated
[START][2021-11-15 18:32:07] LSP logging initiated
[START][2021-11-15 18:49:09] LSP logging initiated
[START][2021-11-15 18:49:18] LSP logging initiated
[START][2021-11-15 18:50:00] LSP logging initiated
[START][2021-11-15 18:52:34] LSP logging initiated
[START][2021-11-15 18:53:46] LSP logging initiated
[START][2021-11-15 18:56:24] LSP logging initiated
[START][2021-11-15 21:23:31] LSP logging initiated
[START][2021-11-15 22:42:08] LSP logging initiated
[START][2021-11-15 23:40:10] LSP logging initiated
[START][2021-11-15 23:57:50] LSP logging initiated
[START][2021-11-16 00:13:08] LSP logging initiated
[START][2021-11-16 00:14:56] LSP logging initiated
[START][2021-11-16 00:19:30] LSP logging initiated
[START][2021-11-16 00:19:42] LSP logging initiated
[START][2021-11-16 00:20:30] LSP logging initiated
[START][2021-11-16 00:29:59] LSP logging initiated
[START][2021-11-16 00:31:17] LSP logging initiated
[START][2021-11-16 00:36:21] LSP logging initiated
[START][2021-11-16 00:38:06] LSP logging initiated
[START][2021-11-16 00:38:32] LSP logging initiated
[START][2021-11-16 00:42:26] LSP logging initiated
[START][2021-11-16 00:43:03] LSP logging initiated
[START][2021-11-16 00:43:32] LSP logging initiated
[START][2021-11-16 01:12:07] LSP logging initiated
[START][2021-11-16 01:14:18] LSP logging initiated
[START][2021-11-16 01:23:12] LSP logging initiated
[START][2021-11-16 01:24:30] LSP logging initiated
[START][2021-11-16 09:50:57] LSP logging initiated
[START][2021-11-16 09:51:06] LSP logging initiated
[START][2021-11-16 09:56:22] LSP logging initiated
[START][2021-11-16 09:58:11] LSP logging initiated
[START][2021-11-16 09:59:58] LSP logging initiated
[START][2021-11-16 10:04:44] LSP logging initiated
[START][2021-11-16 10:08:24] LSP logging initiated
[START][2021-11-16 17:48:35] LSP logging initiated
[START][2021-11-16 21:45:52] LSP logging initiated
[START][2021-11-16 22:08:59] LSP logging initiated
[START][2021-11-17 00:21:22] LSP logging initiated
[START][2021-11-17 00:39:42] LSP logging initiated
[START][2021-11-17 00:46:48] LSP logging initiated
[START][2021-11-17 00:55:45] LSP logging initiated
[START][2021-11-17 09:46:04] LSP logging initiated
[START][2021-11-17 19:24:27] LSP logging initiated
[START][2021-11-18 11:44:24] LSP logging initiated
[START][2021-11-18 11:53:35] LSP logging initiated
[START][2021-11-18 11:46:58] LSP logging initiated
[START][2021-11-18 13:31:04] LSP logging initiated
[START][2021-11-18 14:26:22] LSP logging initiated
[START][2021-11-18 15:23:33] LSP logging initiated
[START][2021-11-18 15:02:07] LSP logging initiated
[START][2021-11-18 14:26:28] LSP logging initiated
[START][2021-11-18 20:22:35] LSP logging initiated
[START][2021-11-19 07:32:52] LSP logging initiated
[START][2021-11-19 15:54:37] LSP logging initiated
[START][2021-11-19 16:18:50] LSP logging initiated
[START][2021-11-19 16:37:37] LSP logging initiated
[START][2021-11-19 16:41:53] LSP logging initiated
[START][2021-11-19 18:51:43] LSP logging initiated
[START][2021-11-19 22:48:40] LSP logging initiated
[START][2021-11-19 22:49:20] LSP logging initiated
[START][2021-11-20 13:31:07] LSP logging initiated
[START][2021-11-20 14:39:18] LSP logging initiated
[START][2021-11-20 13:31:27] LSP logging initiated
[START][2021-11-20 16:50:53] LSP logging initiated
[START][2021-11-20 16:51:25] LSP logging initiated
[START][2021-11-20 16:53:27] LSP logging initiated
[START][2021-11-20 16:53:32] LSP logging initiated
[START][2021-11-20 16:53:59] LSP logging initiated
[START][2021-11-20 17:07:50] LSP logging initiated
[START][2021-11-20 17:05:10] LSP logging initiated
[START][2021-11-20 18:49:14] LSP logging initiated
[START][2021-11-20 20:28:00] LSP logging initiated
[START][2021-11-20 20:28:08] LSP logging initiated
[START][2021-11-20 18:50:49] LSP logging initiated
[START][2021-11-20 20:31:49] LSP logging initiated
[START][2021-11-21 19:42:03] LSP logging initiated
[START][2021-11-22 13:53:37] LSP logging initiated
[START][2021-11-22 19:22:03] LSP logging initiated
[START][2021-11-22 19:22:09] LSP logging initiated
[START][2021-11-22 22:56:52] LSP logging initiated
[START][2021-11-23 07:35:35] LSP logging initiated
[START][2021-11-23 07:36:40] LSP logging initiated
[START][2021-11-23 07:36:51] LSP logging initiated
[START][2021-11-23 07:36:54] LSP logging initiated
[START][2021-11-23 15:39:34] LSP logging initiated
[START][2021-11-23 15:57:41] LSP logging initiated
[START][2021-11-23 15:39:42] LSP logging initiated
[START][2021-11-23 21:36:31] LSP logging initiated
[START][2021-11-23 22:06:37] LSP logging initiated
[START][2021-11-23 22:08:26] LSP logging initiated
[START][2021-11-23 22:14:05] LSP logging initiated
[START][2021-11-24 00:48:35] LSP logging initiated
[START][2021-11-24 12:50:39] LSP logging initiated
[START][2021-11-24 18:10:14] LSP logging initiated
[START][2021-11-24 19:30:48] LSP logging initiated
[START][2021-11-24 19:30:59] LSP logging initiated
[START][2021-11-24 21:16:59] LSP logging initiated
[START][2021-11-26 14:50:22] LSP logging initiated
[START][2021-11-26 19:28:55] LSP logging initiated
[START][2021-11-26 19:37:13] LSP logging initiated
[START][2021-11-26 19:39:38] LSP logging initiated
[START][2021-11-26 19:42:07] LSP logging initiated
[START][2021-11-26 20:03:30] LSP logging initiated
[START][2021-11-28 10:49:37] LSP logging initiated
[START][2021-11-28 10:50:04] LSP logging initiated
[START][2021-12-01 17:00:53] LSP logging initiated
[START][2021-12-01 17:01:13] LSP logging initiated
[START][2021-12-01 17:05:28] LSP logging initiated
[START][2021-12-01 17:05:37] LSP logging initiated
[START][2021-12-01 17:05:45] LSP logging initiated
[START][2021-12-02 07:40:23] LSP logging initiated
[START][2021-12-02 17:40:48] LSP logging initiated
[START][2021-12-02 18:09:21] LSP logging initiated
[START][2021-12-02 17:42:49] LSP logging initiated
[START][2021-12-02 17:38:32] LSP logging initiated
[START][2021-12-02 18:33:17] LSP logging initiated
[START][2021-12-02 18:48:35] LSP logging initiated
[START][2021-12-02 18:47:19] LSP logging initiated
[START][2021-12-02 18:50:27] LSP logging initiated
[START][2021-12-02 18:50:45] LSP logging initiated
[START][2021-12-02 19:13:40] LSP logging initiated
[START][2021-12-02 19:31:37] LSP logging initiated
[START][2021-12-02 18:50:17] LSP logging initiated
[START][2021-12-02 19:33:36] LSP logging initiated
[START][2021-12-02 19:37:24] LSP logging initiated
[START][2021-12-02 19:43:34] LSP logging initiated
[START][2021-12-02 19:44:23] LSP logging initiated
[START][2021-12-02 19:33:23] LSP logging initiated
[START][2021-12-02 20:09:15] LSP logging initiated
[START][2021-12-02 20:25:12] LSP logging initiated
[START][2021-12-02 20:25:50] LSP logging initiated
[START][2021-12-02 20:29:57] LSP logging initiated
[START][2021-12-02 20:26:53] LSP logging initiated
[START][2021-12-02 20:53:09] LSP logging initiated
[START][2021-12-02 20:53:44] LSP logging initiated
[START][2021-12-03 07:43:27] LSP logging initiated
[START][2021-12-03 14:48:31] LSP logging initiated
[START][2021-12-03 14:52:18] LSP logging initiated
[START][2021-12-03 15:01:05] LSP logging initiated
[START][2021-12-03 16:16:37] LSP logging initiated
[START][2021-12-03 16:20:11] LSP logging initiated
[START][2021-12-03 15:55:19] LSP logging initiated
[START][2021-12-03 16:22:11] LSP logging initiated
[START][2021-12-03 17:55:04] LSP logging initiated
[START][2021-12-03 17:55:38] LSP logging initiated
[START][2021-12-03 18:10:07] LSP logging initiated
[START][2021-12-03 20:58:38] LSP logging initiated
[START][2021-12-03 20:59:36] LSP logging initiated
[START][2021-12-03 20:59:12] LSP logging initiated
[START][2021-12-03 20:54:28] LSP logging initiated
[START][2021-12-03 20:59:40] LSP logging initiated
[START][2021-12-03 21:04:19] LSP logging initiated
[START][2021-12-03 21:04:28] LSP logging initiated
[START][2021-12-03 21:04:42] LSP logging initiated
[START][2021-12-03 21:12:52] LSP logging initiated
[START][2021-12-03 21:22:23] LSP logging initiated
[START][2021-12-03 21:22:41] LSP logging initiated
[START][2021-12-03 21:23:24] LSP logging initiated
[START][2021-12-03 21:26:01] LSP logging initiated
[START][2021-12-03 21:34:31] LSP logging initiated
[START][2021-12-03 21:35:49] LSP logging initiated
[START][2021-12-03 21:43:52] LSP logging initiated
[START][2021-12-03 21:20:37] LSP logging initiated
[START][2021-12-03 21:15:53] LSP logging initiated
[START][2021-12-03 21:49:24] LSP logging initiated
[START][2021-12-03 22:20:56] LSP logging initiated
[START][2021-12-03 22:22:35] LSP logging initiated
[START][2021-12-03 22:25:00] LSP logging initiated
[START][2021-12-03 22:25:59] LSP logging initiated
[START][2021-12-03 21:52:27] LSP logging initiated
[START][2021-12-03 21:52:01] LSP logging initiated
[START][2021-12-03 22:36:30] LSP logging initiated
[START][2021-12-03 22:40:14] LSP logging initiated
[START][2021-12-03 22:46:35] LSP logging initiated
[START][2021-12-03 22:54:01] LSP logging initiated
[START][2021-12-03 22:58:01] LSP logging initiated
[START][2021-12-03 23:01:53] LSP logging initiated
[START][2021-12-03 23:05:19] LSP logging initiated
[START][2021-12-03 23:07:36] LSP logging initiated
[START][2021-12-03 22:44:34] LSP logging initiated
[START][2021-12-03 23:09:45] LSP logging initiated
[START][2021-12-03 23:17:11] LSP logging initiated
[START][2021-12-03 23:13:01] LSP logging initiated
[START][2021-12-03 23:24:07] LSP logging initiated
[START][2021-12-03 23:16:32] LSP logging initiated
[START][2021-12-03 23:32:46] LSP logging initiated
[START][2021-12-03 23:36:42] LSP logging initiated
[START][2021-12-03 23:40:43] LSP logging initiated
[START][2021-12-03 23:44:01] LSP logging initiated
[START][2021-12-03 23:40:14] LSP logging initiated
[START][2021-12-04 13:17:23] LSP logging initiated
[START][2021-12-04 13:20:00] LSP logging initiated
[START][2021-12-04 13:20:29] LSP logging initiated
[START][2021-12-04 13:20:37] LSP logging initiated
[START][2021-12-04 13:21:44] LSP logging initiated
[START][2021-12-04 13:27:29] LSP logging initiated
[START][2021-12-04 13:30:56] LSP logging initiated
[START][2021-12-04 13:23:19] LSP logging initiated
[START][2021-12-04 14:02:17] LSP logging initiated
[START][2021-12-04 14:17:17] LSP logging initiated
[START][2021-12-04 13:23:07] LSP logging initiated
[START][2021-12-04 13:22:07] LSP logging initiated
[START][2021-12-04 14:19:04] LSP logging initiated
[START][2021-12-04 14:34:02] LSP logging initiated
[START][2021-12-04 14:36:13] LSP logging initiated
[START][2021-12-04 14:19:32] LSP logging initiated
[START][2021-12-04 14:19:17] LSP logging initiated
[START][2021-12-04 15:08:21] LSP logging initiated
[START][2021-12-05 00:01:28] LSP logging initiated
[START][2021-12-05 00:43:48] LSP logging initiated
[START][2021-12-05 11:11:30] LSP logging initiated
[START][2021-12-05 12:15:38] LSP logging initiated
[START][2021-12-05 12:17:15] LSP logging initiated
[START][2021-12-05 12:17:51] LSP logging initiated
[START][2021-12-05 11:15:45] LSP logging initiated
[START][2021-12-05 11:23:59] LSP logging initiated
[START][2021-12-05 12:51:56] LSP logging initiated
[START][2021-12-05 11:22:46] LSP logging initiated
[START][2021-12-05 12:40:40] LSP logging initiated
[START][2021-12-05 12:53:36] LSP logging initiated
[START][2021-12-05 12:55:44] LSP logging initiated
[START][2021-12-05 13:00:11] LSP logging initiated
[START][2021-12-05 13:00:32] LSP logging initiated
[START][2021-12-05 13:02:34] LSP logging initiated
[START][2021-12-05 14:03:47] LSP logging initiated
[START][2021-12-05 14:04:34] LSP logging initiated
[START][2021-12-05 14:02:01] LSP logging initiated
[START][2021-12-05 14:05:23] LSP logging initiated
[START][2021-12-05 13:41:57] LSP logging initiated
[START][2021-12-05 15:01:06] LSP logging initiated
[START][2021-12-05 15:03:13] LSP logging initiated
[START][2021-12-05 15:05:28] LSP logging initiated
[START][2021-12-05 15:05:37] LSP logging initiated
[START][2021-12-05 15:10:14] LSP logging initiated
[START][2021-12-05 18:07:58] LSP logging initiated
[START][2021-12-05 18:08:38] LSP logging initiated
[START][2021-12-05 18:10:16] LSP logging initiated
[START][2021-12-05 18:10:32] LSP logging initiated
[START][2021-12-05 18:11:26] LSP logging initiated
[START][2021-12-05 21:08:32] LSP logging initiated
[START][2021-12-05 21:18:07] LSP logging initiated
[START][2021-12-05 21:13:15] LSP logging initiated
[START][2021-12-06 00:51:00] LSP logging initiated
[START][2021-12-06 01:37:50] LSP logging initiated
[START][2021-12-06 01:39:30] LSP logging initiated
[START][2021-12-06 01:44:02] LSP logging initiated
[START][2021-12-06 01:45:00] LSP logging initiated
[START][2021-12-06 01:48:22] LSP logging initiated
[START][2021-12-06 01:52:42] LSP logging initiated
[START][2021-12-06 08:02:17] LSP logging initiated
[START][2021-12-06 16:02:10] LSP logging initiated
[START][2021-12-06 16:04:04] LSP logging initiated
[START][2021-12-06 16:12:22] LSP logging initiated
[START][2021-12-06 17:01:01] LSP logging initiated
[START][2021-12-06 18:50:47] LSP logging initiated
[START][2021-12-06 19:45:52] LSP logging initiated
[START][2021-12-06 21:26:13] LSP logging initiated
[START][2021-12-07 00:08:25] LSP logging initiated
[START][2021-12-07 00:08:37] LSP logging initiated
[START][2021-12-06 23:58:56] LSP logging initiated
[START][2021-12-07 00:12:57] LSP logging initiated
[START][2021-12-07 00:13:01] LSP logging initiated
[START][2021-12-07 14:17:57] LSP logging initiated
[START][2021-12-07 20:42:18] LSP logging initiated
[START][2021-12-07 20:42:28] LSP logging initiated
[START][2021-12-07 21:07:52] LSP logging initiated
[START][2021-12-07 21:47:05] LSP logging initiated
[START][2021-12-07 22:05:57] LSP logging initiated
[START][2021-12-07 22:18:29] LSP logging initiated
[START][2021-12-07 21:52:31] LSP logging initiated
[START][2021-12-07 22:37:35] LSP logging initiated
[START][2021-12-07 22:40:09] LSP logging initiated
[START][2021-12-07 22:40:32] LSP logging initiated
[START][2021-12-07 22:44:28] LSP logging initiated
[START][2021-12-07 22:47:46] LSP logging initiated
[START][2021-12-07 23:05:36] LSP logging initiated
[START][2021-12-08 00:29:28] LSP logging initiated
[START][2021-12-08 00:29:35] LSP logging initiated
[START][2021-12-08 11:41:36] LSP logging initiated
[START][2021-12-08 13:18:29] LSP logging initiated
[START][2021-12-08 18:40:36] LSP logging initiated
[START][2021-12-08 19:42:15] LSP logging initiated
[START][2021-12-10 14:59:35] LSP logging initiated
[START][2021-12-10 15:53:44] LSP logging initiated
[START][2021-12-10 17:50:00] LSP logging initiated
[START][2021-12-10 19:43:39] LSP logging initiated
[START][2021-12-10 19:52:19] LSP logging initiated
[START][2021-12-10 19:35:25] LSP logging initiated
[START][2021-12-10 20:07:46] LSP logging initiated
[START][2021-12-10 21:34:32] LSP logging initiated
[START][2021-12-10 22:48:26] LSP logging initiated
[START][2021-12-11 00:39:16] LSP logging initiated
[START][2021-12-11 00:41:02] LSP logging initiated
[START][2021-12-12 13:32:37] LSP logging initiated
[START][2021-12-13 00:27:09] LSP logging initiated
[START][2021-12-13 00:27:34] LSP logging initiated
[START][2021-12-13 00:27:53] LSP logging initiated
[START][2021-12-13 14:27:51] LSP logging initiated
[START][2021-12-13 14:28:06] LSP logging initiated
[START][2021-12-13 14:28:42] LSP logging initiated
[START][2021-12-13 14:29:54] LSP logging initiated
[START][2021-12-13 19:12:45] LSP logging initiated
[START][2021-12-13 19:15:55] LSP logging initiated
[START][2021-12-13 19:14:12] LSP logging initiated
[START][2021-12-13 19:16:36] LSP logging initiated
[START][2021-12-13 19:19:21] LSP logging initiated
[START][2021-12-13 19:20:30] LSP logging initiated
[START][2021-12-13 19:20:51] LSP logging initiated
[START][2021-12-13 19:21:24] LSP logging initiated
[START][2021-12-13 20:00:26] LSP logging initiated
[START][2021-12-13 19:21:06] LSP logging initiated
[START][2021-12-14 16:29:51] LSP logging initiated
[START][2021-12-14 16:30:17] LSP logging initiated
[START][2021-12-14 17:41:16] LSP logging initiated
[START][2021-12-14 17:41:44] LSP logging initiated
[START][2021-12-14 17:43:37] LSP logging initiated
[START][2021-12-14 17:43:54] LSP logging initiated
[START][2021-12-14 17:46:05] LSP logging initiated
[START][2021-12-14 17:37:47] LSP logging initiated
[START][2021-12-15 23:42:13] LSP logging initiated
[START][2021-12-15 23:49:52] LSP logging initiated
[START][2021-12-15 23:41:00] LSP logging initiated
[START][2021-12-15 23:56:38] LSP logging initiated
[START][2021-12-16 11:29:08] LSP logging initiated
[START][2021-12-16 11:47:15] LSP logging initiated
[START][2021-12-16 11:28:22] LSP logging initiated
[START][2021-12-16 15:33:24] LSP logging initiated
[START][2021-12-16 16:11:58] LSP logging initiated
[START][2021-12-16 17:15:28] LSP logging initiated
[START][2021-12-16 17:25:47] LSP logging initiated
[START][2021-12-16 17:29:00] LSP logging initiated
[START][2021-12-16 18:03:33] LSP logging initiated
[START][2021-12-16 18:03:25] LSP logging initiated
[START][2021-12-16 23:26:53] LSP logging initiated
[START][2021-12-16 23:40:44] LSP logging initiated
[START][2021-12-17 00:05:33] LSP logging initiated
[START][2021-12-17 00:36:18] LSP logging initiated
[START][2021-12-17 00:36:24] LSP logging initiated
[START][2021-12-17 00:36:27] LSP logging initiated
[START][2021-12-17 00:40:18] LSP logging initiated
[START][2021-12-17 00:40:36] LSP logging initiated
[START][2021-12-17 00:50:16] LSP logging initiated
[START][2021-12-17 00:52:30] LSP logging initiated
[START][2021-12-17 00:50:40] LSP logging initiated
[START][2021-12-17 00:52:54] LSP logging initiated
[START][2021-12-17 00:54:42] LSP logging initiated
[START][2021-12-17 00:53:38] LSP logging initiated
[START][2021-12-17 01:01:14] LSP logging initiated
[START][2021-12-17 02:00:18] LSP logging initiated
[START][2021-12-17 07:15:41] LSP logging initiated
[START][2021-12-17 15:35:26] LSP logging initiated
[START][2021-12-17 16:34:26] LSP logging initiated
[START][2021-12-17 16:34:46] LSP logging initiated
[START][2021-12-17 16:35:04] LSP logging initiated
[START][2021-12-17 16:35:07] LSP logging initiated
[START][2021-12-17 16:36:50] LSP logging initiated
[START][2021-12-17 16:36:39] LSP logging initiated
[START][2021-12-17 16:33:49] LSP logging initiated
[START][2021-12-17 16:44:54] LSP logging initiated
[START][2021-12-17 19:19:57] LSP logging initiated
[START][2021-12-17 19:26:04] LSP logging initiated
[START][2021-12-17 19:23:51] LSP logging initiated
[START][2021-12-17 19:23:22] LSP logging initiated
[START][2021-12-17 19:32:05] LSP logging initiated
[START][2021-12-17 20:47:07] LSP logging initiated
[START][2021-12-17 20:45:28] LSP logging initiated
[START][2021-12-17 20:57:23] LSP logging initiated
[START][2021-12-17 21:03:50] LSP logging initiated
[START][2021-12-17 20:54:09] LSP logging initiated
[START][2021-12-18 21:27:45] LSP logging initiated
[START][2021-12-19 01:08:25] LSP logging initiated
[START][2021-12-19 01:05:44] LSP logging initiated
[START][2021-12-19 02:28:24] LSP logging initiated
[START][2021-12-19 02:29:36] LSP logging initiated
[START][2021-12-19 02:30:43] LSP logging initiated
[START][2021-12-19 15:52:51] LSP logging initiated
[START][2021-12-19 15:53:04] LSP logging initiated
[START][2021-12-19 15:54:21] LSP logging initiated
[START][2021-12-19 15:54:55] LSP logging initiated
[START][2021-12-19 15:58:56] LSP logging initiated
[START][2021-12-19 19:53:14] LSP logging initiated
[START][2021-12-20 11:47:59] LSP logging initiated
[START][2021-12-20 11:52:54] LSP logging initiated
[START][2021-12-21 22:49:40] LSP logging initiated
[START][2021-12-22 11:40:43] LSP logging initiated
[START][2021-12-22 11:41:26] LSP logging initiated
[START][2021-12-22 11:45:05] LSP logging initiated
[START][2021-12-22 11:46:41] LSP logging initiated
[START][2021-12-22 12:43:21] LSP logging initiated
[START][2021-12-22 18:37:50] LSP logging initiated
[START][2021-12-24 14:16:08] LSP logging initiated
[START][2021-12-25 19:30:57] LSP logging initiated
[START][2021-12-25 19:31:15] LSP logging initiated
[START][2021-12-25 19:37:27] LSP logging initiated
[START][2021-12-25 19:30:38] LSP logging initiated
[START][2021-12-25 20:32:05] LSP logging initiated
[START][2021-12-25 21:44:33] LSP logging initiated
[START][2021-12-27 00:20:24] LSP logging initiated
[START][2021-12-27 17:28:11] LSP logging initiated
[START][2021-12-28 17:38:39] LSP logging initiated
[START][2021-12-28 17:46:28] LSP logging initiated
[START][2021-12-28 17:47:31] LSP logging initiated
[START][2021-12-28 17:39:57] LSP logging initiated
[START][2021-12-28 17:29:44] LSP logging initiated
[START][2021-12-30 17:08:59] LSP logging initiated
[START][2021-12-31 14:42:24] LSP logging initiated
[START][2022-01-02 00:19:39] LSP logging initiated
[START][2022-01-03 14:00:22] LSP logging initiated
[START][2022-01-03 14:19:48] LSP logging initiated
[START][2022-01-03 14:21:32] LSP logging initiated
[START][2022-01-03 19:25:52] LSP logging initiated
[START][2022-01-03 19:35:08] LSP logging initiated
[START][2022-01-04 18:52:28] LSP logging initiated
[START][2022-01-04 19:07:15] LSP logging initiated
[START][2022-01-04 20:24:03] LSP logging initiated
[START][2022-01-04 20:25:52] LSP logging initiated
[START][2022-01-04 20:26:06] LSP logging initiated
[START][2022-01-04 20:17:22] LSP logging initiated
[START][2022-01-04 20:27:48] LSP logging initiated
[START][2022-01-05 01:41:17] LSP logging initiated
[START][2022-01-05 01:41:41] LSP logging initiated
[START][2022-01-05 01:42:34] LSP logging initiated
[START][2022-01-05 01:43:34] LSP logging initiated
[START][2022-01-05 01:44:41] LSP logging initiated
[START][2022-01-05 01:46:54] LSP logging initiated
[START][2022-01-05 01:47:33] LSP logging initiated
[START][2022-01-05 01:47:49] LSP logging initiated
[START][2022-01-05 01:49:59] LSP logging initiated
[START][2022-01-05 01:50:47] LSP logging initiated
[START][2022-01-05 01:53:20] LSP logging initiated
[START][2022-01-05 01:53:37] LSP logging initiated
[START][2022-01-05 01:53:46] LSP logging initiated
[START][2022-01-05 02:09:32] LSP logging initiated
[START][2022-01-05 01:56:07] LSP logging initiated
[START][2022-01-05 02:10:07] LSP logging initiated
[START][2022-01-05 03:01:25] LSP logging initiated
[START][2022-01-05 03:02:06] LSP logging initiated
[START][2022-01-05 03:02:10] LSP logging initiated
[START][2022-01-05 02:58:41] LSP logging initiated
[START][2022-01-05 13:46:35] LSP logging initiated
[START][2022-01-05 13:55:40] LSP logging initiated
[START][2022-01-05 13:55:56] LSP logging initiated
[START][2022-01-05 13:49:34] LSP logging initiated
[START][2022-01-05 13:56:25] LSP logging initiated
[START][2022-01-05 16:38:48] LSP logging initiated
[START][2022-01-05 16:39:15] LSP logging initiated
[START][2022-01-05 16:50:04] LSP logging initiated
[START][2022-01-05 16:53:29] LSP logging initiated
[START][2022-01-05 17:19:15] LSP logging initiated
[START][2022-01-05 19:09:15] LSP logging initiated
[START][2022-01-05 15:53:40] LSP logging initiated
[START][2022-01-05 19:09:51] LSP logging initiated
[START][2022-01-05 15:53:47] LSP logging initiated
[START][2022-01-05 19:16:23] LSP logging initiated
[START][2022-01-05 19:20:30] LSP logging initiated
[START][2022-01-05 19:21:23] LSP logging initiated
[START][2022-01-05 19:21:42] LSP logging initiated
[START][2022-01-05 19:21:58] LSP logging initiated
[START][2022-01-05 19:22:55] LSP logging initiated
[START][2022-01-05 19:23:42] LSP logging initiated
[START][2022-01-05 19:23:04] LSP logging initiated
[START][2022-01-05 20:09:48] LSP logging initiated
[START][2022-01-06 16:21:36] LSP logging initiated
[START][2022-01-06 17:52:16] LSP logging initiated
[START][2022-01-06 18:31:26] LSP logging initiated
[START][2022-01-06 19:36:08] LSP logging initiated
[START][2022-01-06 19:04:32] LSP logging initiated
[START][2022-01-06 20:10:31] LSP logging initiated
[START][2022-01-06 20:34:12] LSP logging initiated
[START][2022-01-06 20:35:06] LSP logging initiated
[START][2022-01-06 20:35:11] LSP logging initiated
[START][2022-01-06 20:35:40] LSP logging initiated
[START][2022-01-06 20:24:19] LSP logging initiated
[START][2022-01-06 20:44:16] LSP logging initiated
[START][2022-01-06 21:13:30] LSP logging initiated
[START][2022-01-06 21:17:03] LSP logging initiated
[START][2022-01-06 22:00:08] LSP logging initiated
[START][2022-01-06 22:17:18] LSP logging initiated
[START][2022-01-06 21:14:30] LSP logging initiated
[START][2022-01-06 22:27:50] LSP logging initiated
[START][2022-01-06 21:40:40] LSP logging initiated
[START][2022-01-06 22:00:14] LSP logging initiated
[START][2022-01-06 22:45:30] LSP logging initiated
[START][2022-01-06 22:27:48] LSP logging initiated
[START][2022-01-06 23:11:45] LSP logging initiated
[START][2022-01-06 23:13:13] LSP logging initiated
[START][2022-01-06 23:16:58] LSP logging initiated
[START][2022-01-06 23:16:29] LSP logging initiated
[START][2022-01-07 00:07:43] LSP logging initiated
[START][2022-01-07 00:09:04] LSP logging initiated
[START][2022-01-07 00:09:43] LSP logging initiated
[START][2022-01-07 00:10:27] LSP logging initiated
[START][2022-01-08 17:06:49] LSP logging initiated
[START][2022-01-08 17:13:23] LSP logging initiated
[START][2022-01-08 17:15:07] LSP logging initiated
[START][2022-01-09 03:19:42] LSP logging initiated
[START][2022-01-09 03:36:36] LSP logging initiated
[START][2022-01-09 04:07:16] LSP logging initiated
[START][2022-01-09 04:07:54] LSP logging initiated
[START][2022-01-09 03:42:34] LSP logging initiated
[START][2022-01-09 03:36:34] LSP logging initiated
[START][2022-01-09 04:26:01] LSP logging initiated
[START][2022-01-09 04:43:40] LSP logging initiated
[START][2022-01-09 04:50:22] LSP logging initiated
[START][2022-01-09 04:50:37] LSP logging initiated
[START][2022-01-09 12:53:40] LSP logging initiated
[START][2022-01-09 12:59:12] LSP logging initiated
[START][2022-01-09 13:05:37] LSP logging initiated
[START][2022-01-09 13:04:14] LSP logging initiated
[START][2022-01-09 13:03:49] LSP logging initiated
[START][2022-01-09 20:03:39] LSP logging initiated
[START][2022-01-09 20:03:50] LSP logging initiated
[START][2022-01-09 20:04:08] LSP logging initiated
[START][2022-01-09 20:04:33] LSP logging initiated
[START][2022-01-09 20:41:33] LSP logging initiated
[START][2022-01-09 20:41:43] LSP logging initiated
[START][2022-01-09 20:42:42] LSP logging initiated
[START][2022-01-10 10:38:52] LSP logging initiated
[START][2022-01-10 10:41:13] LSP logging initiated
[START][2022-01-10 10:41:21] LSP logging initiated
[START][2022-01-10 10:42:03] LSP logging initiated
[START][2022-01-10 10:42:24] LSP logging initiated
[START][2022-01-10 10:42:37] LSP logging initiated
[START][2022-01-10 10:50:21] LSP logging initiated
[START][2022-01-10 10:50:35] LSP logging initiated
[START][2022-01-10 11:55:56] LSP logging initiated
[START][2022-01-10 11:56:47] LSP logging initiated
[START][2022-01-10 11:59:16] LSP logging initiated
[START][2022-01-10 12:07:33] LSP logging initiated
[START][2022-01-10 12:00:16] LSP logging initiated
[START][2022-01-11 03:48:51] LSP logging initiated
[START][2022-01-11 03:55:14] LSP logging initiated
[START][2022-01-11 03:56:16] LSP logging initiated
[START][2022-01-11 03:56:30] LSP logging initiated
[START][2022-01-11 15:22:30] LSP logging initiated
[START][2022-01-11 15:22:36] LSP logging initiated
[START][2022-01-11 15:29:20] LSP logging initiated
[START][2022-01-11 15:29:32] LSP logging initiated
[START][2022-01-11 18:48:33] LSP logging initiated
[START][2022-01-16 18:32:23] LSP logging initiated
[START][2022-01-16 18:33:06] LSP logging initiated
[START][2022-01-16 18:33:21] LSP logging initiated
[START][2022-01-16 18:33:43] LSP logging initiated
[START][2022-01-16 18:34:11] LSP logging initiated
[START][2022-01-16 18:34:37] LSP logging initiated
[START][2022-01-16 18:34:44] LSP logging initiated
[START][2022-01-16 18:35:00] LSP logging initiated
[START][2022-01-16 18:35:10] LSP logging initiated
[START][2022-01-16 18:35:39] LSP logging initiated
[START][2022-01-16 18:36:02] LSP logging initiated
[START][2022-01-17 00:14:16] LSP logging initiated
[START][2022-01-17 00:13:04] LSP logging initiated
[START][2022-01-18 21:17:55] LSP logging initiated
[START][2022-01-18 21:18:26] LSP logging initiated
[START][2022-01-21 12:12:18] LSP logging initiated
[START][2022-01-21 12:12:44] LSP logging initiated
[START][2022-01-21 22:38:50] LSP logging initiated
[START][2022-01-21 23:16:01] LSP logging initiated
[START][2022-01-22 01:01:44] LSP logging initiated
[START][2022-01-22 01:11:13] LSP logging initiated
[START][2022-01-22 01:11:48] LSP logging initiated
[START][2022-01-22 01:13:12] LSP logging initiated
[START][2022-01-22 01:42:49] LSP logging initiated
[START][2022-01-22 01:47:44] LSP logging initiated
[START][2022-01-22 01:58:56] LSP logging initiated
[START][2022-01-22 18:11:21] LSP logging initiated
[START][2022-01-22 19:14:22] LSP logging initiated
[START][2022-01-22 19:22:23] LSP logging initiated
[START][2022-01-22 19:22:44] LSP logging initiated
[START][2022-01-22 20:08:33] LSP logging initiated
[START][2022-01-22 20:23:49] LSP logging initiated
[START][2022-01-22 20:38:10] LSP logging initiated
[START][2022-01-22 20:38:42] LSP logging initiated
[START][2022-01-22 20:47:59] LSP logging initiated
[START][2022-01-22 20:50:37] LSP logging initiated
[START][2022-01-23 07:39:08] LSP logging initiated
[START][2022-01-23 08:21:28] LSP logging initiated
[START][2022-01-24 12:06:24] LSP logging initiated
[START][2022-01-24 12:10:23] LSP logging initiated
[START][2022-01-24 12:17:36] LSP logging initiated
[START][2022-01-26 21:35:55] LSP logging initiated
[START][2022-01-26 21:36:46] LSP logging initiated
[START][2022-01-29 20:41:01] LSP logging initiated
[START][2022-01-30 15:00:26] LSP logging initiated
[START][2022-01-30 15:03:18] LSP logging initiated
[START][2022-01-31 19:27:15] LSP logging initiated
[START][2022-01-31 19:28:55] LSP logging initiated
[START][2022-01-31 19:29:46] LSP logging initiated
[START][2022-01-31 19:42:11] LSP logging initiated
[START][2022-01-31 19:40:19] LSP logging initiated
[START][2022-01-31 19:41:20] LSP logging initiated
[START][2022-01-31 19:44:32] LSP logging initiated
[START][2022-02-02 22:38:13] LSP logging initiated
[START][2022-02-02 22:38:31] LSP logging initiated
[START][2022-02-02 22:10:31] LSP logging initiated
[START][2022-02-02 22:38:45] LSP logging initiated
[START][2022-02-02 22:13:15] LSP logging initiated
[START][2022-02-03 00:04:48] LSP logging initiated
[START][2022-02-03 00:05:30] LSP logging initiated
[START][2022-02-03 22:25:31] LSP logging initiated
[START][2022-02-03 22:26:11] LSP logging initiated
[START][2022-02-04 17:59:54] LSP logging initiated
[START][2022-02-04 21:20:24] LSP logging initiated
[START][2022-02-04 21:20:49] LSP logging initiated
[START][2022-02-05 00:41:47] LSP logging initiated
[START][2022-02-08 21:13:34] LSP logging initiated
[START][2022-02-09 10:19:47] LSP logging initiated
[START][2022-02-10 01:25:22] LSP logging initiated
[START][2022-02-11 07:43:08] LSP logging initiated
[START][2022-02-11 07:43:34] LSP logging initiated
[START][2022-02-11 15:17:59] LSP logging initiated
[START][2022-02-11 16:04:14] LSP logging initiated
[START][2022-02-11 17:36:39] LSP logging initiated
[START][2022-02-11 17:24:53] LSP logging initiated
[START][2022-02-12 11:25:28] LSP logging initiated
[START][2022-02-13 18:56:39] LSP logging initiated
[START][2022-02-15 00:11:35] LSP logging initiated
[START][2022-02-16 11:12:39] LSP logging initiated
[START][2022-02-18 00:34:12] LSP logging initiated
[START][2022-02-18 12:48:40] LSP logging initiated
[START][2022-02-18 16:03:46] LSP logging initiated
[START][2022-02-18 16:06:29] LSP logging initiated
[START][2022-02-18 16:07:20] LSP logging initiated
[START][2022-02-18 16:07:47] LSP logging initiated
[START][2022-02-18 16:08:14] LSP logging initiated
[START][2022-02-18 16:08:25] LSP logging initiated
[START][2022-02-18 16:08:35] LSP logging initiated
[START][2022-02-18 16:08:58] LSP logging initiated
[START][2022-02-18 16:09:40] LSP logging initiated
[START][2022-02-18 16:10:43] LSP logging initiated
[START][2022-02-18 17:57:39] LSP logging initiated
[START][2022-02-18 17:58:06] LSP logging initiated
[START][2022-02-19 03:30:53] LSP logging initiated
[START][2022-02-19 03:46:36] LSP logging initiated
[START][2022-02-19 10:08:05] LSP logging initiated
[START][2022-02-19 10:19:11] LSP logging initiated
[START][2022-02-19 10:19:29] LSP logging initiated
[START][2022-02-19 11:17:25] LSP logging initiated
[START][2022-02-24 14:41:34] LSP logging initiated
[START][2022-02-24 15:16:51] LSP logging initiated
[START][2022-02-24 15:19:32] LSP logging initiated
[START][2022-02-24 15:19:52] LSP logging initiated
[START][2022-02-25 17:38:35] LSP logging initiated
[START][2022-02-25 17:40:54] LSP logging initiated
[START][2022-02-26 00:41:35] LSP logging initiated
[START][2022-02-26 00:46:29] LSP logging initiated
[START][2022-02-26 00:46:39] LSP logging initiated
[START][2022-02-26 00:48:26] LSP logging initiated
[START][2022-02-26 00:49:28] LSP logging initiated
[START][2022-02-26 00:49:42] LSP logging initiated
[START][2022-02-26 13:27:57] LSP logging initiated
[START][2022-02-26 13:52:23] LSP logging initiated
[START][2022-02-26 13:58:58] LSP logging initiated
[START][2022-02-26 13:59:29] LSP logging initiated
[START][2022-02-26 14:12:57] LSP logging initiated
[START][2022-02-26 13:51:22] LSP logging initiated
[START][2022-02-26 14:45:56] LSP logging initiated
[START][2022-02-26 14:13:25] LSP logging initiated
[START][2022-02-26 14:51:48] LSP logging initiated
[START][2022-02-26 14:53:53] LSP logging initiated
[START][2022-02-26 15:42:24] LSP logging initiated
[START][2022-02-26 15:47:25] LSP logging initiated
[START][2022-02-26 15:59:35] LSP logging initiated
[START][2022-02-27 16:45:36] LSP logging initiated
[START][2022-02-28 09:40:28] LSP logging initiated
[START][2022-03-01 13:49:25] LSP logging initiated
[START][2022-03-01 19:42:33] LSP logging initiated
[START][2022-03-01 21:38:20] LSP logging initiated
[START][2022-03-01 21:38:24] LSP logging initiated
[START][2022-03-01 21:39:12] LSP logging initiated
[START][2022-03-01 21:39:16] LSP logging initiated
[START][2022-03-01 21:40:32] LSP logging initiated
[START][2022-03-01 21:40:56] LSP logging initiated
[START][2022-03-02 19:27:46] LSP logging initiated
[START][2022-03-02 23:46:37] LSP logging initiated
[START][2022-03-02 23:50:00] LSP logging initiated
[START][2022-03-02 23:50:09] LSP logging initiated
[START][2022-03-02 23:02:55] LSP logging initiated
[START][2022-03-02 23:55:32] LSP logging initiated
[START][2022-03-03 00:29:50] LSP logging initiated
[START][2022-03-03 16:03:22] LSP logging initiated
[START][2022-03-03 16:04:00] LSP logging initiated
[START][2022-03-03 22:19:57] LSP logging initiated
[START][2022-03-04 12:23:27] LSP logging initiated
[START][2022-03-04 22:34:43] LSP logging initiated
[START][2022-03-04 22:38:28] LSP logging initiated
[START][2022-03-04 22:44:12] LSP logging initiated
[START][2022-03-04 22:48:25] LSP logging initiated
[START][2022-03-09 19:46:13] LSP logging initiated
[START][2022-03-15 10:21:36] LSP logging initiated
[START][2022-03-15 10:30:05] LSP logging initiated
[START][2022-03-15 10:24:10] LSP logging initiated
[START][2022-03-15 11:48:54] LSP logging initiated
[START][2022-03-15 11:49:01] LSP logging initiated
[START][2022-03-15 10:22:36] LSP logging initiated
[START][2022-03-15 18:38:41] LSP logging initiated
[START][2022-03-15 18:44:48] LSP logging initiated
[START][2022-03-16 10:06:44] LSP logging initiated
[START][2022-03-16 20:40:01] LSP logging initiated
[START][2022-03-18 13:01:32] LSP logging initiated
[START][2022-03-18 13:02:50] LSP logging initiated
[START][2022-03-18 13:03:01] LSP logging initiated
[START][2022-03-20 14:52:58] LSP logging initiated
[START][2022-03-20 14:56:43] LSP logging initiated
[START][2022-03-21 09:25:29] LSP logging initiated
[START][2022-03-21 09:26:36] LSP logging initiated
[START][2022-03-21 09:27:20] LSP logging initiated
[START][2022-03-21 09:27:44] LSP logging initiated
[START][2022-03-21 09:28:51] LSP logging initiated
[START][2022-03-21 09:29:41] LSP logging initiated
[START][2022-03-21 09:32:42] LSP logging initiated
[START][2022-03-21 09:33:11] LSP logging initiated
[START][2022-03-21 09:33:20] LSP logging initiated
[START][2022-03-21 09:39:57] LSP logging initiated
[START][2022-03-21 09:40:32] LSP logging initiated
[START][2022-03-21 09:35:58] LSP logging initiated
[START][2022-03-21 09:48:03] LSP logging initiated
[START][2022-03-21 09:49:57] LSP logging initiated
[START][2022-03-21 09:50:03] LSP logging initiated
[START][2022-03-21 10:12:39] LSP logging initiated
[START][2022-03-21 10:13:58] LSP logging initiated
[START][2022-03-22 00:12:07] LSP logging initiated
[START][2022-03-22 00:13:37] LSP logging initiated
[START][2022-03-22 00:32:03] LSP logging initiated
[START][2022-03-22 00:45:27] LSP logging initiated
[START][2022-03-22 00:48:58] LSP logging initiated
[START][2022-03-22 00:58:27] LSP logging initiated
[START][2022-03-22 01:18:26] LSP logging initiated
[START][2022-03-22 15:40:51] LSP logging initiated
[START][2022-03-22 15:41:49] LSP logging initiated
[START][2022-03-22 15:43:46] LSP logging initiated
[START][2022-03-22 16:32:31] LSP logging initiated
[START][2022-03-22 17:32:26] LSP logging initiated
[START][2022-03-23 12:48:56] LSP logging initiated
[START][2022-03-23 12:49:00] LSP logging initiated
[START][2022-03-23 12:49:24] LSP logging initiated
[START][2022-03-23 12:49:58] LSP logging initiated
[START][2022-03-23 12:46:43] LSP logging initiated
[START][2022-03-23 12:53:44] LSP logging initiated
[START][2022-03-24 00:01:10] LSP logging initiated
[START][2022-03-24 01:33:45] LSP logging initiated
[START][2022-03-24 13:37:37] LSP logging initiated
[START][2022-03-24 13:38:09] LSP logging initiated
[START][2022-03-24 13:38:35] LSP logging initiated
[START][2022-03-24 14:08:54] LSP logging initiated
[START][2022-03-24 14:13:45] LSP logging initiated
[START][2022-03-24 14:14:27] LSP logging initiated
[START][2022-03-25 14:14:32] LSP logging initiated
[START][2022-03-25 14:39:07] LSP logging initiated
[START][2022-03-25 15:52:41] LSP logging initiated
[START][2022-03-25 15:53:29] LSP logging initiated
[START][2022-03-25 16:05:19] LSP logging initiated
[START][2022-03-25 16:05:40] LSP logging initiated
[START][2022-03-25 15:54:02] LSP logging initiated
[START][2022-03-25 15:15:51] LSP logging initiated
[START][2022-03-25 15:16:23] LSP logging initiated
[START][2022-03-26 00:12:53] LSP logging initiated
[START][2022-03-26 00:02:03] LSP logging initiated
[START][2022-03-26 14:19:28] LSP logging initiated
[START][2022-03-26 16:05:09] LSP logging initiated
[START][2022-03-26 18:42:41] LSP logging initiated
[START][2022-03-26 16:17:28] LSP logging initiated
[START][2022-03-26 17:18:18] LSP logging initiated
[START][2022-03-26 19:24:27] LSP logging initiated
[START][2022-03-26 21:24:01] LSP logging initiated
[START][2022-03-27 00:00:07] LSP logging initiated
[START][2022-03-27 01:06:17] LSP logging initiated
[START][2022-03-27 01:11:24] LSP logging initiated
[START][2022-03-27 01:15:34] LSP logging initiated
[START][2022-03-26 23:35:11] LSP logging initiated
[START][2022-03-27 01:33:36] LSP logging initiated
[START][2022-03-27 15:40:43] LSP logging initiated
[START][2022-03-27 15:50:00] LSP logging initiated
[START][2022-03-27 16:29:52] LSP logging initiated
[START][2022-03-28 14:05:47] LSP logging initiated
[START][2022-03-28 22:20:44] LSP logging initiated
[START][2022-03-29 01:08:04] LSP logging initiated
[START][2022-03-29 01:09:38] LSP logging initiated
[START][2022-03-29 10:06:23] LSP logging initiated
[START][2022-03-29 10:58:26] LSP logging initiated
[START][2022-03-29 11:01:59] LSP logging initiated
[START][2022-03-29 21:37:41] LSP logging initiated
[START][2022-03-29 21:45:14] LSP logging initiated
[START][2022-03-29 22:32:46] LSP logging initiated
[START][2022-03-29 22:44:30] LSP logging initiated
[START][2022-03-29 22:45:11] LSP logging initiated
[START][2022-03-30 02:17:10] LSP logging initiated
[START][2022-03-30 17:42:24] LSP logging initiated
[START][2022-03-31 13:46:39] LSP logging initiated
[START][2022-03-31 13:49:10] LSP logging initiated
[START][2022-03-31 16:52:27] LSP logging initiated
[START][2022-03-31 18:20:19] LSP logging initiated
[START][2022-03-31 18:36:55] LSP logging initiated
[START][2022-03-31 18:59:36] LSP logging initiated
[START][2022-03-31 19:07:42] LSP logging initiated
[START][2022-03-31 20:55:33] LSP logging initiated
[START][2022-03-31 19:42:19] LSP logging initiated
[START][2022-03-31 19:36:14] LSP logging initiated
[START][2022-03-31 21:17:40] LSP logging initiated
[START][2022-03-31 21:23:32] LSP logging initiated
[START][2022-03-31 21:23:49] LSP logging initiated
[START][2022-03-31 21:24:22] LSP logging initiated
[START][2022-03-31 21:25:07] LSP logging initiated
[START][2022-03-31 21:25:19] LSP logging initiated
[START][2022-03-31 21:25:27] LSP logging initiated
[START][2022-03-31 21:25:40] LSP logging initiated
[START][2022-03-31 21:25:51] LSP logging initiated
[START][2022-03-31 21:48:55] LSP logging initiated
[START][2022-03-31 21:50:16] LSP logging initiated
[START][2022-03-31 21:32:51] LSP logging initiated
[START][2022-03-31 22:38:11] LSP logging initiated
[START][2022-04-01 15:14:12] LSP logging initiated
[START][2022-04-01 15:41:28] LSP logging initiated
[START][2022-04-01 15:57:55] LSP logging initiated
[START][2022-04-01 15:59:47] LSP logging initiated
[START][2022-04-01 16:00:24] LSP logging initiated
[START][2022-04-01 16:23:50] LSP logging initiated
[START][2022-04-01 16:24:15] LSP logging initiated
[START][2022-04-01 16:43:08] LSP logging initiated
[START][2022-04-01 16:44:13] LSP logging initiated
[START][2022-04-01 16:02:13] LSP logging initiated
[START][2022-04-01 16:39:34] LSP logging initiated
[START][2022-04-01 17:47:05] LSP logging initiated
[START][2022-04-01 18:24:39] LSP logging initiated
[START][2022-04-01 18:59:22] LSP logging initiated
[START][2022-04-01 18:53:29] LSP logging initiated
[START][2022-04-01 18:33:30] LSP logging initiated
[START][2022-04-01 19:00:35] LSP logging initiated
[START][2022-04-01 17:47:11] LSP logging initiated
[START][2022-04-01 19:00:56] LSP logging initiated
[START][2022-04-01 19:09:17] LSP logging initiated
[START][2022-04-01 19:04:49] LSP logging initiated
[START][2022-04-01 19:28:34] LSP logging initiated
[START][2022-04-01 19:11:22] LSP logging initiated
[START][2022-04-01 19:33:49] LSP logging initiated
[START][2022-04-01 19:34:12] LSP logging initiated
[START][2022-04-01 19:15:20] LSP logging initiated
[START][2022-04-01 19:38:56] LSP logging initiated
[START][2022-04-01 19:35:35] LSP logging initiated
[START][2022-04-01 19:43:32] LSP logging initiated
[START][2022-04-01 19:43:50] LSP logging initiated
[START][2022-04-01 19:41:22] LSP logging initiated
[START][2022-04-01 19:47:33] LSP logging initiated
[START][2022-04-01 20:06:55] LSP logging initiated
[START][2022-04-01 20:18:30] LSP logging initiated
[START][2022-04-01 19:36:15] LSP logging initiated
[START][2022-04-01 20:23:13] LSP logging initiated
[START][2022-04-01 20:23:40] LSP logging initiated
[START][2022-04-01 20:23:51] LSP logging initiated
[START][2022-04-01 20:21:30] LSP logging initiated
[START][2022-04-01 19:45:31] LSP logging initiated
[START][2022-04-01 19:51:06] LSP logging initiated
[START][2022-04-01 20:08:57] LSP logging initiated
[START][2022-04-01 19:51:08] LSP logging initiated
[START][2022-04-01 20:24:43] LSP logging initiated
[START][2022-04-01 20:25:05] LSP logging initiated
[START][2022-04-01 20:27:45] LSP logging initiated
[START][2022-04-02 14:58:48] LSP logging initiated
[START][2022-04-02 15:31:52] LSP logging initiated
[START][2022-04-02 16:39:45] LSP logging initiated
[START][2022-04-02 16:40:44] LSP logging initiated
[START][2022-04-02 16:52:19] LSP logging initiated
[START][2022-04-03 15:32:25] LSP logging initiated
[START][2022-04-03 16:34:54] LSP logging initiated
[START][2022-04-03 22:27:06] LSP logging initiated
[START][2022-04-03 22:27:11] LSP logging initiated
[START][2022-04-03 23:05:30] LSP logging initiated
[START][2022-04-04 10:15:11] LSP logging initiated
[START][2022-04-04 10:24:51] LSP logging initiated
[START][2022-04-04 13:06:16] LSP logging initiated
[START][2022-04-04 13:20:27] LSP logging initiated
[START][2022-04-04 13:53:59] LSP logging initiated
[START][2022-04-04 14:03:44] LSP logging initiated
[START][2022-04-04 15:04:48] LSP logging initiated
[START][2022-04-04 16:26:43] LSP logging initiated
[START][2022-04-04 16:38:14] LSP logging initiated
[START][2022-04-04 22:25:34] LSP logging initiated
[START][2022-04-04 23:09:34] LSP logging initiated
[START][2022-04-05 14:03:10] LSP logging initiated
[START][2022-04-06 16:01:30] LSP logging initiated
[START][2022-04-06 15:17:03] LSP logging initiated
[START][2022-04-06 19:39:35] LSP logging initiated
[START][2022-04-06 19:40:01] LSP logging initiated
[START][2022-04-07 15:28:14] LSP logging initiated
[START][2022-04-07 15:28:34] LSP logging initiated
[START][2022-04-07 20:23:13] LSP logging initiated
[START][2022-04-07 20:31:57] LSP logging initiated
[START][2022-04-08 21:31:07] LSP logging initiated
[START][2022-04-08 22:14:40] LSP logging initiated
[START][2022-04-08 22:17:50] LSP logging initiated
[START][2022-04-08 22:33:30] LSP logging initiated
[START][2022-04-08 22:37:05] LSP logging initiated
[START][2022-04-08 22:48:51] LSP logging initiated
[START][2022-04-08 22:44:57] LSP logging initiated
[START][2022-04-09 01:04:53] LSP logging initiated
[START][2022-04-09 01:39:28] LSP logging initiated
[START][2022-04-09 02:13:13] LSP logging initiated
[START][2022-04-09 01:35:26] LSP logging initiated
[START][2022-04-10 02:47:00] LSP logging initiated
[START][2022-04-10 19:15:44] LSP logging initiated
[START][2022-04-11 15:04:48] LSP logging initiated
[START][2022-04-11 16:16:22] LSP logging initiated
[START][2022-04-11 16:18:33] LSP logging initiated
[START][2022-04-11 16:19:48] LSP logging initiated
[START][2022-04-11 16:42:02] LSP logging initiated
[START][2022-04-11 16:42:52] LSP logging initiated
[START][2022-04-11 16:43:44] LSP logging initiated
[START][2022-04-12 09:41:17] LSP logging initiated
[START][2022-04-12 09:50:21] LSP logging initiated
[START][2022-04-12 09:51:22] LSP logging initiated
[START][2022-04-12 09:52:30] LSP logging initiated
[START][2022-04-12 10:01:07] LSP logging initiated
[START][2022-04-12 15:15:46] LSP logging initiated
[START][2022-04-13 20:08:40] LSP logging initiated
[START][2022-04-14 01:40:25] LSP logging initiated
[START][2022-04-14 15:02:07] LSP logging initiated
[START][2022-04-14 16:19:14] LSP logging initiated
[START][2022-04-14 22:16:11] LSP logging initiated
[START][2022-04-14 22:20:29] LSP logging initiated
[START][2022-04-14 22:33:05] LSP logging initiated
[START][2022-04-15 14:28:57] LSP logging initiated
[START][2022-04-15 16:47:10] LSP logging initiated
[START][2022-04-15 19:58:55] LSP logging initiated
[START][2022-04-15 20:59:46] LSP logging initiated
[START][2022-04-15 21:00:01] LSP logging initiated
[START][2022-04-15 21:00:34] LSP logging initiated
[START][2022-04-15 21:01:13] LSP logging initiated
[START][2022-04-15 21:01:44] LSP logging initiated
[START][2022-04-15 21:01:47] LSP logging initiated
[START][2022-04-15 21:01:52] LSP logging initiated
[START][2022-04-15 21:04:13] LSP logging initiated
[START][2022-04-15 21:19:15] LSP logging initiated
[START][2022-04-15 21:52:45] LSP logging initiated
[START][2022-04-15 21:53:00] LSP logging initiated
[START][2022-04-15 21:57:46] LSP logging initiated
[START][2022-04-15 22:01:02] LSP logging initiated
[START][2022-04-15 23:19:02] LSP logging initiated
[START][2022-04-15 23:19:09] LSP logging initiated
[START][2022-04-15 23:19:32] LSP logging initiated
[START][2022-04-15 23:19:49] LSP logging initiated
[START][2022-04-15 23:21:39] LSP logging initiated
[START][2022-04-15 23:27:10] LSP logging initiated
[START][2022-04-15 23:27:50] LSP logging initiated
[START][2022-04-15 23:32:27] LSP logging initiated
[START][2022-04-15 23:40:14] LSP logging initiated
[START][2022-04-15 23:40:25] LSP logging initiated
[START][2022-04-15 23:40:45] LSP logging initiated
[START][2022-04-15 23:47:19] LSP logging initiated
[START][2022-04-15 23:47:46] LSP logging initiated
[START][2022-04-15 23:33:08] LSP logging initiated
[START][2022-04-15 23:47:52] LSP logging initiated
[START][2022-04-16 00:02:57] LSP logging initiated
[START][2022-04-15 21:55:10] LSP logging initiated
[START][2022-04-16 00:04:18] LSP logging initiated
[START][2022-04-16 00:04:24] LSP logging initiated
[START][2022-04-16 00:04:55] LSP logging initiated
[START][2022-04-16 00:04:59] LSP logging initiated
[START][2022-04-16 00:05:15] LSP logging initiated
[START][2022-04-16 00:05:05] LSP logging initiated
[START][2022-04-16 00:05:50] LSP logging initiated
[START][2022-04-16 02:33:30] LSP logging initiated
[START][2022-04-16 02:36:52] LSP logging initiated
[START][2022-04-16 02:37:40] LSP logging initiated
[START][2022-04-16 02:28:58] LSP logging initiated
[START][2022-04-16 02:38:20] LSP logging initiated
[START][2022-04-16 02:38:45] LSP logging initiated
[START][2022-04-16 02:39:08] LSP logging initiated
[START][2022-04-16 02:40:16] LSP logging initiated
[START][2022-04-16 02:33:02] LSP logging initiated
[START][2022-04-16 02:33:33] LSP logging initiated
[START][2022-04-16 02:41:44] LSP logging initiated
[START][2022-04-16 02:42:17] LSP logging initiated
[START][2022-04-16 12:52:33] LSP logging initiated
[START][2022-04-16 12:54:10] LSP logging initiated
[START][2022-04-16 13:03:32] LSP logging initiated
[START][2022-04-16 13:03:51] LSP logging initiated
[START][2022-04-16 17:26:26] LSP logging initiated
[START][2022-04-16 17:27:16] LSP logging initiated
[START][2022-04-16 17:28:48] LSP logging initiated
[START][2022-04-16 18:31:03] LSP logging initiated
[START][2022-04-16 18:31:15] LSP logging initiated
[START][2022-04-16 18:31:33] LSP logging initiated
[START][2022-04-16 20:37:10] LSP logging initiated
[START][2022-04-16 20:37:50] LSP logging initiated
[START][2022-04-16 20:37:53] LSP logging initiated
[START][2022-04-16 20:37:56] LSP logging initiated
[START][2022-04-16 20:39:25] LSP logging initiated
[START][2022-04-16 20:36:36] LSP logging initiated
[START][2022-04-16 20:40:02] LSP logging initiated
[START][2022-04-16 20:42:44] LSP logging initiated
[START][2022-04-16 20:43:32] LSP logging initiated
[START][2022-04-16 20:44:38] LSP logging initiated
[START][2022-04-16 20:45:03] LSP logging initiated
[START][2022-04-16 20:48:23] LSP logging initiated
[START][2022-04-16 20:48:51] LSP logging initiated
[START][2022-04-16 20:49:45] LSP logging initiated
[START][2022-04-16 20:40:14] LSP logging initiated
[START][2022-04-16 20:40:17] LSP logging initiated
[START][2022-04-16 20:51:35] LSP logging initiated
[START][2022-04-17 09:40:56] LSP logging initiated
[START][2022-04-17 22:04:19] LSP logging initiated
[START][2022-04-18 09:44:38] LSP logging initiated
[START][2022-04-18 21:22:51] LSP logging initiated
[START][2022-04-18 22:07:46] LSP logging initiated
[START][2022-04-18 22:05:43] LSP logging initiated
[START][2022-04-18 22:34:08] LSP logging initiated
[START][2022-04-19 08:48:21] LSP logging initiated
[START][2022-04-19 14:56:23] LSP logging initiated
[START][2022-04-19 16:21:47] LSP logging initiated
[START][2022-04-19 21:41:42] LSP logging initiated
[START][2022-04-19 22:22:13] LSP logging initiated
[START][2022-04-19 22:30:53] LSP logging initiated
[START][2022-04-19 22:31:53] LSP logging initiated
[START][2022-04-20 00:56:22] LSP logging initiated
[START][2022-04-20 00:57:36] LSP logging initiated
[START][2022-04-21 10:41:23] LSP logging initiated
[START][2022-04-21 10:54:53] LSP logging initiated
[START][2022-04-21 15:27:01] LSP logging initiated
[START][2022-04-21 20:19:23] LSP logging initiated
[START][2022-04-22 08:54:47] LSP logging initiated
[START][2022-04-22 21:00:06] LSP logging initiated
[START][2022-04-22 21:16:06] LSP logging initiated
[START][2022-04-22 21:16:02] LSP logging initiated
[START][2022-04-22 21:16:34] LSP logging initiated
[START][2022-04-23 10:02:24] LSP logging initiated
[START][2022-04-23 11:58:24] LSP logging initiated
[START][2022-04-23 14:56:05] LSP logging initiated
[START][2022-04-24 10:25:58] LSP logging initiated
[START][2022-04-24 11:00:53] LSP logging initiated
[START][2022-04-24 11:29:06] LSP logging initiated
[START][2022-04-24 10:44:34] LSP logging initiated
[START][2022-04-24 13:33:50] LSP logging initiated
[START][2022-04-24 14:22:45] LSP logging initiated
[START][2022-04-24 14:26:57] LSP logging initiated
[START][2022-04-24 18:05:13] LSP logging initiated
[START][2022-04-24 18:12:46] LSP logging initiated
[START][2022-04-24 16:48:28] LSP logging initiated
[START][2022-04-24 18:57:51] LSP logging initiated
[START][2022-04-24 19:07:33] LSP logging initiated
[START][2022-04-24 23:25:31] LSP logging initiated
[START][2022-04-25 00:24:20] LSP logging initiated
[START][2022-04-25 09:41:25] LSP logging initiated
[START][2022-04-25 10:01:09] LSP logging initiated
[START][2022-04-25 22:28:42] LSP logging initiated
[START][2022-04-26 14:39:04] LSP logging initiated
[START][2022-04-26 14:40:43] LSP logging initiated
[START][2022-04-26 14:38:36] LSP logging initiated
[START][2022-04-26 14:41:24] LSP logging initiated
[START][2022-04-26 14:39:45] LSP logging initiated
[START][2022-04-26 21:17:52] LSP logging initiated
[START][2022-04-26 21:17:56] LSP logging initiated
[START][2022-04-26 22:08:50] LSP logging initiated
[START][2022-04-26 22:09:26] LSP logging initiated
[START][2022-04-26 22:20:04] LSP logging initiated
[START][2022-04-26 22:20:09] LSP logging initiated
[START][2022-04-26 22:22:05] LSP logging initiated
[START][2022-04-26 22:34:48] LSP logging initiated
[START][2022-04-26 22:40:33] LSP logging initiated
[START][2022-04-26 22:42:59] LSP logging initiated
[START][2022-04-26 22:49:01] LSP logging initiated
[START][2022-04-26 22:49:45] LSP logging initiated
[START][2022-04-26 22:20:31] LSP logging initiated
[START][2022-04-26 22:51:59] LSP logging initiated
[START][2022-04-26 22:53:00] LSP logging initiated
[START][2022-04-26 22:53:49] LSP logging initiated
[START][2022-04-27 12:45:35] LSP logging initiated
[START][2022-04-27 12:41:45] LSP logging initiated
[START][2022-04-27 16:05:18] LSP logging initiated
[START][2022-04-27 16:21:01] LSP logging initiated
[START][2022-04-27 16:16:06] LSP logging initiated
[START][2022-04-27 16:42:08] LSP logging initiated
[START][2022-04-27 16:42:16] LSP logging initiated
[START][2022-04-27 17:52:51] LSP logging initiated
[START][2022-04-27 17:53:20] LSP logging initiated
[START][2022-04-27 17:53:31] LSP logging initiated
[START][2022-04-27 17:54:40] LSP logging initiated
[START][2022-04-27 17:55:58] LSP logging initiated
[START][2022-04-27 21:48:44] LSP logging initiated
[START][2022-04-28 13:51:58] LSP logging initiated
[START][2022-04-28 13:52:09] LSP logging initiated
[START][2022-04-28 13:57:40] LSP logging initiated
[START][2022-04-28 14:49:47] LSP logging initiated
[START][2022-04-28 18:11:32] LSP logging initiated
[START][2022-04-28 20:38:27] LSP logging initiated
[START][2022-04-29 11:38:07] LSP logging initiated
[START][2022-04-29 11:40:00] LSP logging initiated
[START][2022-04-29 12:09:41] LSP logging initiated
[START][2022-04-29 12:15:46] LSP logging initiated
[START][2022-04-29 12:15:53] LSP logging initiated
[START][2022-04-29 12:16:01] LSP logging initiated
[START][2022-04-29 12:16:38] LSP logging initiated
[START][2022-04-29 12:19:16] LSP logging initiated
[START][2022-04-29 12:19:51] LSP logging initiated
[START][2022-04-29 12:21:04] LSP logging initiated
[START][2022-04-29 12:21:30] LSP logging initiated
[START][2022-04-29 12:21:54] LSP logging initiated
[START][2022-04-29 12:23:00] LSP logging initiated
[START][2022-04-29 12:23:38] LSP logging initiated
[START][2022-04-29 12:24:24] LSP logging initiated
[START][2022-04-29 12:24:49] LSP logging initiated
[START][2022-04-29 12:25:42] LSP logging initiated
[START][2022-04-29 12:26:07] LSP logging initiated
[START][2022-04-29 12:14:03] LSP logging initiated
[START][2022-04-29 12:26:36] LSP logging initiated
[START][2022-04-29 12:27:09] LSP logging initiated
[START][2022-04-29 12:28:18] LSP logging initiated
[START][2022-04-29 12:28:55] LSP logging initiated
[START][2022-04-29 12:29:05] LSP logging initiated
[START][2022-04-29 12:29:35] LSP logging initiated
[START][2022-04-29 12:14:20] LSP logging initiated
[START][2022-04-29 12:34:25] LSP logging initiated
[START][2022-04-29 12:37:42] LSP logging initiated
[START][2022-04-29 12:38:46] LSP logging initiated
[START][2022-04-29 12:40:06] LSP logging initiated
[START][2022-04-29 12:40:32] LSP logging initiated
[START][2022-04-29 12:37:29] LSP logging initiated
[START][2022-04-29 12:42:25] LSP logging initiated
[START][2022-04-29 12:48:57] LSP logging initiated
[START][2022-04-29 12:31:49] LSP logging initiated
[START][2022-04-29 12:35:27] LSP logging initiated
[START][2022-04-29 12:58:37] LSP logging initiated
[START][2022-04-29 12:59:03] LSP logging initiated
[START][2022-04-29 13:00:00] LSP logging initiated
[START][2022-04-29 13:28:51] LSP logging initiated
[START][2022-04-29 13:24:28] LSP logging initiated
[START][2022-04-29 13:39:04] LSP logging initiated
[START][2022-04-29 13:43:51] LSP logging initiated
[START][2022-04-29 13:45:45] LSP logging initiated
[START][2022-04-29 13:47:55] LSP logging initiated
[START][2022-04-29 13:48:23] LSP logging initiated
[START][2022-04-29 13:50:41] LSP logging initiated
[START][2022-04-29 13:51:48] LSP logging initiated
[START][2022-04-29 13:42:06] LSP logging initiated
[START][2022-04-29 13:52:29] LSP logging initiated
[START][2022-04-29 14:03:43] LSP logging initiated
[START][2022-04-29 13:40:14] LSP logging initiated
[START][2022-04-29 15:09:24] LSP logging initiated
[START][2022-04-29 17:08:20] LSP logging initiated
[START][2022-04-29 18:03:51] LSP logging initiated
[START][2022-04-29 18:04:48] LSP logging initiated
[START][2022-04-29 18:04:42] LSP logging initiated
[START][2022-04-29 19:20:00] LSP logging initiated
[START][2022-04-29 19:03:48] LSP logging initiated
[START][2022-04-29 19:37:46] LSP logging initiated
[START][2022-04-29 20:09:55] LSP logging initiated
[START][2022-04-29 22:03:39] LSP logging initiated
[START][2022-04-29 22:09:47] LSP logging initiated
[START][2022-04-29 22:08:10] LSP logging initiated
[START][2022-04-29 22:29:22] LSP logging initiated
[START][2022-04-29 22:27:41] LSP logging initiated
[START][2022-04-29 23:08:02] LSP logging initiated
[START][2022-04-30 09:46:27] LSP logging initiated
[START][2022-04-30 10:24:11] LSP logging initiated
[START][2022-04-30 11:44:33] LSP logging initiated
[START][2022-04-30 10:53:47] LSP logging initiated
[START][2022-04-30 12:45:48] LSP logging initiated
[START][2022-04-30 13:15:33] LSP logging initiated
[START][2022-04-30 13:19:41] LSP logging initiated
[START][2022-04-30 13:20:13] LSP logging initiated
[START][2022-04-30 13:09:14] LSP logging initiated
[START][2022-04-30 13:20:24] LSP logging initiated
[START][2022-04-30 13:45:20] LSP logging initiated
[START][2022-04-30 14:34:29] LSP logging initiated
[START][2022-04-30 16:47:34] LSP logging initiated
[START][2022-04-30 16:50:11] LSP logging initiated
[START][2022-04-30 18:03:09] LSP logging initiated
[START][2022-04-30 18:05:40] LSP logging initiated
[START][2022-04-30 19:06:45] LSP logging initiated
[START][2022-04-30 17:22:41] LSP logging initiated
[START][2022-04-30 19:25:47] LSP logging initiated
[START][2022-04-30 19:46:02] LSP logging initiated
[START][2022-04-30 19:47:15] LSP logging initiated
[START][2022-04-30 19:54:18] LSP logging initiated
[START][2022-04-30 19:54:44] LSP logging initiated
[START][2022-04-30 20:07:33] LSP logging initiated
[START][2022-04-30 20:21:14] LSP logging initiated
[START][2022-04-30 20:22:58] LSP logging initiated
[START][2022-04-30 20:24:20] LSP logging initiated
[START][2022-04-30 20:33:42] LSP logging initiated
[START][2022-04-30 20:37:19] LSP logging initiated
[START][2022-04-30 21:43:05] LSP logging initiated
[START][2022-04-30 20:48:07] LSP logging initiated
[START][2022-04-30 19:45:39] LSP logging initiated
[START][2022-04-30 21:43:23] LSP logging initiated
[START][2022-04-30 22:17:14] LSP logging initiated
[START][2022-04-30 22:30:16] LSP logging initiated
[START][2022-04-30 22:35:27] LSP logging initiated
[START][2022-04-30 23:25:59] LSP logging initiated
[START][2022-05-01 10:14:35] LSP logging initiated
[START][2022-05-01 10:46:10] LSP logging initiated
[START][2022-05-01 12:12:55] LSP logging initiated
[START][2022-05-01 15:13:30] LSP logging initiated
[START][2022-05-01 15:13:38] LSP logging initiated
[START][2022-05-01 15:14:01] LSP logging initiated
[START][2022-05-01 15:29:12] LSP logging initiated
[START][2022-05-01 15:29:49] LSP logging initiated
[START][2022-05-01 15:37:55] LSP logging initiated
[START][2022-05-01 15:41:07] LSP logging initiated
[START][2022-05-01 15:14:12] LSP logging initiated
[START][2022-05-01 15:57:54] LSP logging initiated
[START][2022-05-01 17:48:24] LSP logging initiated
[START][2022-05-01 18:17:35] LSP logging initiated
[START][2022-05-01 20:21:03] LSP logging initiated
[START][2022-05-01 21:35:32] LSP logging initiated
[START][2022-05-01 22:20:09] LSP logging initiated
[START][2022-05-01 22:29:28] LSP logging initiated
[START][2022-05-01 22:58:11] LSP logging initiated
[START][2022-05-02 11:48:33] LSP logging initiated
[START][2022-05-02 11:49:46] LSP logging initiated
[START][2022-05-02 11:50:29] LSP logging initiated
[START][2022-05-02 09:55:38] LSP logging initiated
[START][2022-05-02 11:50:43] LSP logging initiated
[START][2022-05-02 12:00:03] LSP logging initiated
[START][2022-05-02 11:59:37] LSP logging initiated
[START][2022-05-02 14:06:32] LSP logging initiated
[START][2022-05-02 14:35:45] LSP logging initiated
[START][2022-05-02 14:54:26] LSP logging initiated
[START][2022-05-02 16:15:01] LSP logging initiated
[START][2022-05-02 16:15:08] LSP logging initiated
[START][2022-05-02 16:16:52] LSP logging initiated
[START][2022-05-02 16:45:32] LSP logging initiated
[START][2022-05-02 16:52:00] LSP logging initiated
[START][2022-05-02 19:57:57] LSP logging initiated
[START][2022-05-02 22:42:25] LSP logging initiated
[START][2022-05-03 10:36:46] LSP logging initiated
[START][2022-05-03 11:28:09] LSP logging initiated
[START][2022-05-03 11:35:18] LSP logging initiated
[START][2022-05-03 13:46:43] LSP logging initiated
[START][2022-05-03 14:57:59] LSP logging initiated
[START][2022-05-03 14:59:42] LSP logging initiated
[START][2022-05-03 15:16:37] LSP logging initiated
[START][2022-05-03 15:47:41] LSP logging initiated
[START][2022-05-03 16:22:53] LSP logging initiated
[START][2022-05-03 18:24:15] LSP logging initiated
[START][2022-05-03 19:28:24] LSP logging initiated
[START][2022-05-03 21:10:31] LSP logging initiated
[START][2022-05-04 05:17:35] LSP logging initiated
[START][2022-05-04 05:20:34] LSP logging initiated
[START][2022-05-04 06:12:15] LSP logging initiated
[START][2022-05-04 06:58:09] LSP logging initiated
[START][2022-05-04 08:37:43] LSP logging initiated
[START][2022-05-04 07:09:08] LSP logging initiated
[START][2022-05-04 10:44:16] LSP logging initiated
[START][2022-05-04 11:57:49] LSP logging initiated
[START][2022-05-04 12:46:20] LSP logging initiated
[START][2022-05-04 12:56:30] LSP logging initiated
[START][2022-05-04 13:02:22] LSP logging initiated
[START][2022-05-04 13:40:13] LSP logging initiated
[START][2022-05-04 14:16:35] LSP logging initiated
[START][2022-05-04 15:49:25] LSP logging initiated
[START][2022-05-04 15:24:41] LSP logging initiated
[START][2022-05-04 15:54:55] LSP logging initiated
[START][2022-05-04 15:59:35] LSP logging initiated
[START][2022-05-04 16:06:50] LSP logging initiated
[START][2022-05-04 17:03:50] LSP logging initiated
[START][2022-05-04 16:30:39] LSP logging initiated
[START][2022-05-04 21:30:46] LSP logging initiated
[START][2022-05-05 10:34:00] LSP logging initiated
[START][2022-05-05 11:57:46] LSP logging initiated
[START][2022-05-05 17:31:25] LSP logging initiated
[START][2022-05-05 16:27:51] LSP logging initiated
[START][2022-05-05 19:18:07] LSP logging initiated
[START][2022-05-05 19:34:07] LSP logging initiated
[START][2022-05-05 21:14:16] LSP logging initiated
[START][2022-05-06 10:02:45] LSP logging initiated
[START][2022-05-06 10:54:52] LSP logging initiated
[START][2022-05-06 11:09:27] LSP logging initiated
[START][2022-05-06 11:11:05] LSP logging initiated
[START][2022-05-06 11:11:45] LSP logging initiated
[START][2022-05-06 11:11:57] LSP logging initiated
[START][2022-05-06 11:26:03] LSP logging initiated
[START][2022-05-06 12:25:05] LSP logging initiated
[START][2022-05-06 12:30:37] LSP logging initiated
[START][2022-05-06 12:38:50] LSP logging initiated
[START][2022-05-06 12:43:53] LSP logging initiated
[START][2022-05-06 18:56:34] LSP logging initiated
[START][2022-05-06 19:13:37] LSP logging initiated
[START][2022-05-06 19:10:31] LSP logging initiated
[START][2022-05-06 21:36:09] LSP logging initiated
[START][2022-05-06 22:08:37] LSP logging initiated
[START][2022-05-06 23:12:53] LSP logging initiated
[START][2022-05-07 11:15:51] LSP logging initiated
[START][2022-05-07 12:52:31] LSP logging initiated
[START][2022-05-07 13:07:19] LSP logging initiated
[START][2022-05-07 13:12:02] LSP logging initiated
[START][2022-05-07 13:15:19] LSP logging initiated
[START][2022-05-07 13:15:39] LSP logging initiated
[START][2022-05-07 13:43:56] LSP logging initiated
[START][2022-05-07 14:22:03] LSP logging initiated
[START][2022-05-07 14:37:31] LSP logging initiated
[START][2022-05-07 13:58:34] LSP logging initiated
[START][2022-05-07 15:05:20] LSP logging initiated
[START][2022-05-07 21:25:09] LSP logging initiated
[START][2022-05-08 12:05:23] LSP logging initiated
[START][2022-05-08 16:24:29] LSP logging initiated
[START][2022-05-09 09:42:31] LSP logging initiated
[START][2022-05-09 10:41:47] LSP logging initiated
[START][2022-05-09 12:02:22] LSP logging initiated
[START][2022-05-09 14:19:09] LSP logging initiated
[START][2022-05-09 23:17:48] LSP logging initiated
[START][2022-05-10 07:40:48] LSP logging initiated
[START][2022-05-10 08:04:52] LSP logging initiated
[START][2022-05-10 10:18:25] LSP logging initiated
[START][2022-05-10 10:39:51] LSP logging initiated
[START][2022-05-10 10:56:24] LSP logging initiated
[START][2022-05-10 11:02:02] LSP logging initiated
[START][2022-05-10 11:10:11] LSP logging initiated
[START][2022-05-11 07:56:10] LSP logging initiated
[START][2022-05-11 09:37:34] LSP logging initiated
[START][2022-05-11 09:51:38] LSP logging initiated
[START][2022-05-11 10:10:23] LSP logging initiated
[START][2022-05-11 10:10:44] LSP logging initiated
[START][2022-05-11 10:22:12] LSP logging initiated
[START][2022-05-11 13:51:39] LSP logging initiated
[START][2022-05-11 16:02:56] LSP logging initiated
[START][2022-05-11 16:07:48] LSP logging initiated
[START][2022-05-11 15:28:20] LSP logging initiated
[START][2022-05-11 17:44:08] LSP logging initiated
[START][2022-05-11 19:11:50] LSP logging initiated
[START][2022-05-12 09:02:02] LSP logging initiated
[START][2022-05-12 09:20:09] LSP logging initiated
[START][2022-05-12 09:03:28] LSP logging initiated
[START][2022-05-12 10:26:23] LSP logging initiated
[START][2022-05-12 11:01:05] LSP logging initiated
[START][2022-05-12 12:01:31] LSP logging initiated
[START][2022-05-12 20:42:30] LSP logging initiated
[START][2022-05-12 20:43:27] LSP logging initiated
[START][2022-05-12 20:44:09] LSP logging initiated
[START][2022-05-12 20:48:16] LSP logging initiated
[START][2022-05-12 20:49:21] LSP logging initiated
[START][2022-05-12 23:14:22] LSP logging initiated
[START][2022-05-13 09:47:13] LSP logging initiated
[START][2022-05-13 09:58:00] LSP logging initiated
[START][2022-05-13 10:00:05] LSP logging initiated
[START][2022-05-13 13:40:27] LSP logging initiated
[START][2022-05-13 14:43:03] LSP logging initiated
[START][2022-05-13 22:07:28] LSP logging initiated
[START][2022-05-14 12:19:55] LSP logging initiated
[START][2022-05-16 18:57:03] LSP logging initiated
[START][2022-05-17 13:53:26] LSP logging initiated
[START][2022-05-17 13:54:36] LSP logging initiated
[START][2022-05-17 13:54:54] LSP logging initiated
[START][2022-05-17 14:17:25] LSP logging initiated
[START][2022-05-17 14:49:52] LSP logging initiated
[START][2022-05-17 15:05:28] LSP logging initiated
[START][2022-05-17 15:56:27] LSP logging initiated
[START][2022-05-19 12:12:29] LSP logging initiated
[START][2022-05-19 12:28:07] LSP logging initiated
[START][2022-05-19 12:28:58] LSP logging initiated
[START][2022-05-19 13:26:27] LSP logging initiated
[START][2022-05-19 13:26:35] LSP logging initiated
[START][2022-05-19 14:05:46] LSP logging initiated
[START][2022-05-19 15:25:00] LSP logging initiated
[START][2022-05-19 15:44:10] LSP logging initiated
[START][2022-05-19 19:08:53] LSP logging initiated
[START][2022-05-19 19:11:39] LSP logging initiated
[START][2022-05-19 19:31:16] LSP logging initiated
[START][2022-05-19 19:51:14] LSP logging initiated
[START][2022-05-19 20:39:47] LSP logging initiated
[START][2022-05-19 20:54:24] LSP logging initiated
[START][2022-05-19 21:41:25] LSP logging initiated
[START][2022-05-20 10:03:47] LSP logging initiated
[START][2022-05-20 10:44:30] LSP logging initiated
[START][2022-05-20 18:14:26] LSP logging initiated
[START][2022-05-20 18:46:31] LSP logging initiated
[START][2022-05-21 01:28:04] LSP logging initiated
[START][2022-05-21 10:13:05] LSP logging initiated
[START][2022-05-21 12:58:03] LSP logging initiated
[START][2022-05-21 13:41:16] LSP logging initiated
[START][2022-05-21 14:01:59] LSP logging initiated
[START][2022-05-21 17:49:10] LSP logging initiated
[START][2022-05-21 18:42:38] LSP logging initiated
[START][2022-05-21 19:57:02] LSP logging initiated
[START][2022-05-21 20:14:11] LSP logging initiated
[START][2022-05-21 20:22:54] LSP logging initiated
[START][2022-05-22 09:31:22] LSP logging initiated
[START][2022-05-22 09:32:20] LSP logging initiated
[START][2022-05-22 10:15:25] LSP logging initiated
[START][2022-05-22 11:23:46] LSP logging initiated
[START][2022-05-22 11:28:39] LSP logging initiated
[START][2022-05-22 14:36:10] LSP logging initiated
[START][2022-05-24 13:33:53] LSP logging initiated
[START][2022-05-24 14:47:49] LSP logging initiated
[START][2022-05-24 14:48:35] LSP logging initiated
[START][2022-05-24 14:48:45] LSP logging initiated
[START][2022-05-24 14:49:00] LSP logging initiated
[START][2022-05-24 14:49:14] LSP logging initiated
[START][2022-05-25 17:53:45] LSP logging initiated
[START][2022-05-25 17:53:58] LSP logging initiated
[START][2022-05-25 18:05:17] LSP logging initiated
[START][2022-05-25 18:08:41] LSP logging initiated
[START][2022-05-25 18:15:23] LSP logging initiated
[START][2022-05-25 18:16:55] LSP logging initiated
[START][2022-05-25 18:17:28] LSP logging initiated
[START][2022-05-25 18:21:35] LSP logging initiated
[START][2022-05-25 18:18:06] LSP logging initiated
[START][2022-05-25 18:27:14] LSP logging initiated
[START][2022-05-25 18:20:00] LSP logging initiated
[START][2022-05-25 18:24:01] LSP logging initiated
[START][2022-05-25 19:22:58] LSP logging initiated
[START][2022-05-25 19:30:02] LSP logging initiated
[START][2022-05-25 19:27:57] LSP logging initiated
[START][2022-05-25 19:31:29] LSP logging initiated
[START][2022-05-25 18:06:12] LSP logging initiated
[START][2022-05-25 20:58:59] LSP logging initiated
[START][2022-05-25 21:22:22] LSP logging initiated
[START][2022-05-25 21:25:42] LSP logging initiated
[START][2022-05-25 21:39:05] LSP logging initiated
[START][2022-05-25 21:43:00] LSP logging initiated
[START][2022-05-27 10:25:23] LSP logging initiated
[START][2022-05-27 10:28:33] LSP logging initiated
[START][2022-05-27 12:01:00] LSP logging initiated
[START][2022-05-27 12:01:16] LSP logging initiated
[START][2022-05-27 14:03:27] LSP logging initiated
[START][2022-05-27 19:46:57] LSP logging initiated
[START][2022-05-28 20:47:50] LSP logging initiated
[START][2022-05-28 20:48:02] LSP logging initiated
[START][2022-05-28 20:48:29] LSP logging initiated
[START][2022-05-28 20:48:38] LSP logging initiated
[START][2022-05-28 20:49:42] LSP logging initiated
[START][2022-05-28 20:50:14] LSP logging initiated
[START][2022-05-28 20:50:31] LSP logging initiated
[START][2022-05-28 21:00:04] LSP logging initiated
[START][2022-05-28 21:04:21] LSP logging initiated
[START][2022-05-28 21:08:46] LSP logging initiated
[START][2022-05-28 21:30:43] LSP logging initiated
[START][2022-05-28 21:39:25] LSP logging initiated
[START][2022-05-28 21:42:52] LSP logging initiated
[START][2022-05-28 21:43:04] LSP logging initiated
[START][2022-05-28 21:46:24] LSP logging initiated
[START][2022-05-28 21:56:42] LSP logging initiated
[START][2022-05-28 21:56:53] LSP logging initiated
[START][2022-05-28 21:57:02] LSP logging initiated
[START][2022-05-28 21:57:43] LSP logging initiated
[START][2022-05-28 22:13:07] LSP logging initiated
[START][2022-05-28 22:16:07] LSP logging initiated
[START][2022-05-28 22:08:28] LSP logging initiated
[START][2022-05-28 22:19:50] LSP logging initiated
[START][2022-05-28 22:19:19] LSP logging initiated
[START][2022-05-28 22:34:22] LSP logging initiated
[START][2022-05-29 10:35:14] LSP logging initiated
[START][2022-05-29 10:35:21] LSP logging initiated
[START][2022-05-29 11:00:26] LSP logging initiated
[START][2022-05-29 20:49:07] LSP logging initiated
[START][2022-05-29 20:56:38] LSP logging initiated
[START][2022-05-29 20:56:58] LSP logging initiated
[START][2022-05-29 21:19:00] LSP logging initiated
[START][2022-05-29 21:19:13] LSP logging initiated
[START][2022-05-31 12:03:07] LSP logging initiated
[START][2022-05-31 12:03:33] LSP logging initiated
[START][2022-05-31 12:03:47] LSP logging initiated
[START][2022-06-01 15:29:37] LSP logging initiated
[START][2022-06-01 15:29:52] LSP logging initiated
[START][2022-06-02 12:31:11] LSP logging initiated
[START][2022-06-02 12:34:12] LSP logging initiated
[START][2022-06-02 12:34:46] LSP logging initiated
[START][2022-06-02 12:36:05] LSP logging initiated
[START][2022-06-02 12:40:24] LSP logging initiated
[START][2022-06-02 12:40:27] LSP logging initiated
[START][2022-06-02 12:35:09] LSP logging initiated
[START][2022-06-02 12:36:29] LSP logging initiated
[START][2022-06-02 12:41:59] LSP logging initiated
[START][2022-06-03 11:05:39] LSP logging initiated
[START][2022-06-03 11:13:12] LSP logging initiated
[START][2022-06-03 11:13:19] LSP logging initiated
[START][2022-06-03 11:13:30] LSP logging initiated
[START][2022-06-03 11:13:33] LSP logging initiated
[START][2022-06-03 11:10:09] LSP logging initiated
[START][2022-06-03 11:16:54] LSP logging initiated
[START][2022-06-04 19:40:36] LSP logging initiated
[START][2022-06-04 19:42:29] LSP logging initiated
[START][2022-06-04 19:42:52] LSP logging initiated
[START][2022-06-04 19:46:28] LSP logging initiated
[START][2022-06-04 19:46:32] LSP logging initiated
[START][2022-06-04 19:47:31] LSP logging initiated
[START][2022-06-04 21:55:16] LSP logging initiated
[START][2022-06-04 21:47:10] LSP logging initiated
[START][2022-06-04 21:55:45] LSP logging initiated
[START][2022-06-05 10:22:43] LSP logging initiated
[START][2022-06-05 10:23:16] LSP logging initiated
[START][2022-06-05 10:59:15] LSP logging initiated
[START][2022-06-05 11:01:45] LSP logging initiated
[START][2022-06-05 11:02:11] LSP logging initiated
[START][2022-06-05 11:02:26] LSP logging initiated
[START][2022-06-05 11:03:35] LSP logging initiated
[START][2022-06-05 11:10:07] LSP logging initiated
[START][2022-06-05 11:10:13] LSP logging initiated
[START][2022-06-05 11:14:54] LSP logging initiated
[START][2022-06-05 11:14:39] LSP logging initiated
[START][2022-06-05 11:18:53] LSP logging initiated
[START][2022-06-05 11:19:37] LSP logging initiated
[START][2022-06-05 11:23:22] LSP logging initiated
[START][2022-06-05 11:15:47] LSP logging initiated
[START][2022-06-05 11:23:51] LSP logging initiated
[START][2022-06-05 11:31:52] LSP logging initiated
[START][2022-06-05 11:25:23] LSP logging initiated
[START][2022-06-05 11:31:57] LSP logging initiated
[START][2022-06-05 11:33:16] LSP logging initiated
[START][2022-06-05 11:05:50] LSP logging initiated
[START][2022-06-05 11:33:28] LSP logging initiated
[START][2022-06-05 11:32:03] LSP logging initiated
[START][2022-06-05 11:38:33] LSP logging initiated
[START][2022-06-05 11:38:54] LSP logging initiated
[START][2022-06-05 11:38:59] LSP logging initiated
[START][2022-06-05 11:49:02] LSP logging initiated
[START][2022-06-05 13:59:14] LSP logging initiated
[START][2022-06-05 13:59:19] LSP logging initiated
[START][2022-06-05 14:06:40] LSP logging initiated
[START][2022-06-05 14:00:37] LSP logging initiated
[START][2022-06-05 14:06:48] LSP logging initiated
[START][2022-06-05 14:07:20] LSP logging initiated
[START][2022-06-05 15:31:42] LSP logging initiated
[START][2022-06-05 21:11:54] LSP logging initiated
[START][2022-06-05 21:13:41] LSP logging initiated
[START][2022-06-05 21:14:38] LSP logging initiated
[START][2022-06-05 21:26:19] LSP logging initiated
[START][2022-06-05 21:26:42] LSP logging initiated
[START][2022-06-05 21:27:11] LSP logging initiated
[START][2022-06-05 21:28:23] LSP logging initiated
[START][2022-06-06 14:03:36] LSP logging initiated
[START][2022-06-06 14:06:24] LSP logging initiated
[START][2022-06-06 14:06:34] LSP logging initiated
[START][2022-06-06 14:13:53] LSP logging initiated
[START][2022-06-06 14:17:28] LSP logging initiated
[START][2022-06-06 14:17:37] LSP logging initiated
[START][2022-06-06 14:18:04] LSP logging initiated
[START][2022-06-06 14:21:11] LSP logging initiated
[START][2022-06-06 14:26:05] LSP logging initiated
[START][2022-06-06 14:26:22] LSP logging initiated
[START][2022-06-06 14:26:44] LSP logging initiated
[START][2022-06-06 14:26:49] LSP logging initiated
[START][2022-06-06 14:27:05] LSP logging initiated
[START][2022-06-06 14:29:59] LSP logging initiated
[START][2022-06-06 14:30:28] LSP logging initiated
[START][2022-06-06 14:32:00] LSP logging initiated
[START][2022-06-06 14:42:22] LSP logging initiated
[START][2022-06-06 15:09:02] LSP logging initiated
[ERROR][2022-06-06 15:14:40] .../vim/lsp/rpc.lua:420	"rpc"	"rust-analyzer"	"stderr"	'[ERROR rust_analyzer::dispatch] unknown request: Request { id: RequestId(I32(287)), method: "workspace/executeCommand", params: Object({"command": String("editor.action.triggerParameterHints"), "title": String("triggerParameterHints")}) }\n'
[ERROR][2022-06-06 15:17:21] .../vim/lsp/rpc.lua:420	"rpc"	"rust-analyzer"	"stderr"	'[ERROR rust_analyzer::dispatch] unknown request: Request { id: RequestId(I32(541)), method: "workspace/executeCommand", params: Object({"command": String("editor.action.triggerParameterHints"), "title": String("triggerParameterHints")}) }\n'
[ERROR][2022-06-06 15:17:30] .../vim/lsp/rpc.lua:420	"rpc"	"rust-analyzer"	"stderr"	'[ERROR rust_analyzer::dispatch] unknown request: Request { id: RequestId(I32(557)), method: "workspace/executeCommand", params: Object({"command": String("editor.action.triggerParameterHints"), "title": String("triggerParameterHints")}) }\n'
[START][2022-06-06 15:59:01] LSP logging initiated
[START][2022-06-06 21:03:10] LSP logging initiated
[ERROR][2022-06-06 21:03:19] .../vim/lsp/rpc.lua:420	"rpc"	"rust-analyzer"	"stderr"	'[ERROR rust_analyzer::lsp_utils] rust-analyzer failed to load workspace: Failed to read Cargo metadata from Cargo.toml file /home/jtcf/rustworks/factorio-mlua/Cargo.toml, cargo 1.61.0 (a028ae4 2022-04-29): Failed to run `"cargo" "metadata" "--format-version" "1" "--manifest-path" "/home/jtcf/rustworks/factorio-mlua/Cargo.toml" "--filter-platform" "x86_64-unknown-linux-gnu"`: `cargo metadata` exited with an error: error: failed to parse manifest at `/home/jtcf/rustworks/factorio-mlua/Cargo.toml`\n\nCaused by:\n  could not parse input as TOML\n\nCaused by:\n  TOML parse error at line 2, column 1\n    |\n  2 | <<<<<<< HEAD\n    | ^\n  Could not parse the line\n\n'
[ERROR][2022-06-06 21:03:20] .../vim/lsp/rpc.lua:420	"rpc"	"rust-analyzer"	"stderr"	'[ERROR rust_analyzer::lsp_utils] rust-analyzer failed to load workspace: Failed to read Cargo metadata from Cargo.toml file /home/jtcf/rustworks/factorio-mlua/Cargo.toml, cargo 1.61.0 (a028ae4 2022-04-29): Failed to run `"cargo" "metadata" "--format-version" "1" "--manifest-path" "/home/jtcf/rustworks/factorio-mlua/Cargo.toml" "--filter-platform" "x86_64-unknown-linux-gnu"`: `cargo metadata` exited with an error: error: failed to parse manifest at `/home/jtcf/rustworks/factorio-mlua/Cargo.toml`\n\nCaused by:\n  could not parse input as TOML\n\nCaused by:\n  TOML parse error at line 2, column 1\n    |\n  2 | <<<<<<< HEAD\n    | ^\n  Could not parse the line\n\n'
[START][2022-06-06 21:04:27] LSP logging initiated
[ERROR][2022-06-06 21:04:46] .../vim/lsp/rpc.lua:420	"rpc"	"rust-analyzer"	"stderr"	'[ERROR rust_analyzer::lsp_utils] rust-analyzer failed to run build scripts\n\nerror: You must enable one of the features: lua54, lua53, lua52, lua51, luajit, luajit52, luau, lua-factorio\n  --> build/main.rs:55:5\n   |\n55 | /     compile_error!(\n56 | |         "You must enable one of the features: lua54, lua53, lua52, lua51, luajit, luajit52, luau, lua-factorio"\n57 | |     );\n   | |_____^\n\n\nerror: aborting due to previous error\n\n\nerror: could not compile `factorio-mlua` due to 2 previous errors\n\n\n'
[START][2022-06-06 21:05:35] LSP logging initiated
[START][2022-06-06 21:12:01] LSP logging initiated
[ERROR][2022-06-06 21:17:24] .../vim/lsp/rpc.lua:420	"rpc"	"rust-analyzer"	"stderr"	'[ERROR rust_analyzer::dispatch] unknown request: Request { id: RequestId(I32(195)), method: "workspace/executeCommand", params: Object({"command": String("editor.action.triggerParameterHints"), "title": String("triggerParameterHints")}) }\n'
[START][2022-06-06 21:27:57] LSP logging initiated
[START][2022-06-06 21:30:55] LSP logging initiated
[START][2022-06-06 21:28:02] LSP logging initiated
[START][2022-06-06 21:31:00] LSP logging initiated
[START][2022-06-07 16:26:19] LSP logging initiated
[START][2022-06-07 17:31:24] LSP logging initiated
[START][2022-06-07 17:44:56] LSP logging initiated
[START][2022-06-07 19:14:53] LSP logging initiated
[START][2022-06-07 19:40:07] LSP logging initiated
[START][2022-06-07 19:55:15] LSP logging initiated
[START][2022-06-07 19:55:46] LSP logging initiated
[START][2022-06-07 20:23:33] LSP logging initiated
[START][2022-06-07 20:37:50] LSP logging initiated
[START][2022-06-07 21:32:42] LSP logging initiated
[START][2022-06-08 10:03:43] LSP logging initiated
[START][2022-06-08 11:20:42] LSP logging initiated
[ERROR][2022-06-08 11:21:20] .../vim/lsp/rpc.lua:534	"No callback found for server response id 7"
[ERROR][2022-06-08 11:21:20] .../lua/vim/lsp.lua:824	"LSP[rust_analyzer]"	"on_error"	{  code = "NO_RESULT_CALLBACK_FOUND",  err = {    id = 7,    jsonrpc = "2.0",    result = {      isIncomplete = true,      items = { {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "Utilities for formatting and printing `String`s.\n\nThis module contains the runtime support for the [`format!`] syntax extension.\nThis macro is implemented in the compiler to emit calls to this module in\norder to format arguments at runtime into strings.\n\n# Usage\n\nThe [`format!`] macro is intended to be familiar to those coming from C's\n`printf`/`fprintf` functions or Python's `str.format` function.\n\nSome examples of the [`format!`] extension are:\n\n```rust\nformat!(\"Hello\");                 // => \"Hello\"\nformat!(\"Hello, {}!\", \"world\");   // => \"Hello, world!\"\nformat!(\"The number is {}\", 1);   // => \"The number is 1\"\nformat!(\"{:?}\", (3, 4));          // => \"(3, 4)\"\nformat!(\"{value}\", value=4);      // => \"4\"\nlet people = \"Rustaceans\";\nformat!(\"Hello {people}!\");       // => \"Hello Rustaceans!\"\nformat!(\"{} {}\", 1, 2);           // => \"1 2\"\nformat!(\"{:04}\", 42);             // => \"0042\" with leading zeros\nformat!(\"{:#?}\", (100, 200));     // => \"(\n                                  //       100,\n                                  //       200,\n                                  //     )\"\n```\n\nFrom these, you can see that the first argument is a format string. It is\nrequired by the compiler for this to be a string literal; it cannot be a\nvariable passed in (in order to perform validity checking). The compiler\nwill then parse the format string and determine if the list of arguments\nprovided is suitable to pass to this format string.\n\nTo convert a single value to a string, use the [`to_string`] method. This\nwill use the [`Display`] formatting trait.\n\n## Positional parameters\n\nEach formatting argument is allowed to specify which value argument it's\nreferencing, and if omitted it is assumed to be \"the next argument\". For\nexample, the format string `{} {} {}` would take three parameters, and they\nwould be formatted in the same order as they're given. The format string\n`{2} {1} {0}`, however, would format arguments in reverse order.\n\nThings can get a little tricky once you start intermingling the two types of\npositional specifiers. The \"next argument\" specifier can be thought of as an\niterator over the argument. Each time a \"next argument\" specifier is seen,\nthe iterator advances. This leads to behavior like this:\n\n```rust\nformat!(\"{1} {} {0} {}\", 1, 2); // => \"2 1 1 2\"\n```\n\nThe internal iterator over the argument has not been advanced by the time\nthe first `{}` is seen, so it prints the first argument. Then upon reaching\nthe second `{}`, the iterator has advanced forward to the second argument.\nEssentially, parameters that explicitly name their argument do not affect\nparameters that do not name an argument in terms of positional specifiers.\n\nA format string is required to use all of its arguments, otherwise it is a\ncompile-time error. You may refer to the same argument more than once in the\nformat string.\n\n## Named parameters\n\nRust itself does not have a Python-like equivalent of named parameters to a\nfunction, but the [`format!`] macro is a syntax extension that allows it to\nleverage named parameters. Named parameters are listed at the end of the\nargument list and have the syntax:\n\n```text\nidentifier '=' expression\n```\n\nFor example, the following [`format!`] expressions all use named arguments:\n\n```rust\nformat!(\"{argument}\", argument = \"test\");   // => \"test\"\nformat!(\"{name} {}\", 1, name = 2);          // => \"2 1\"\nformat!(\"{a} {c} {b}\", a=\"a\", b='b', c=3);  // => \"a 3 b\"\n```\n\nIf a named parameter does not appear in the argument list, `format!` will\nreference a variable with that name in the current scope.\n\n```rust\nlet argument = 2 + 2;\nformat!(\"{argument}\");   // => \"4\"\n\nfn make_string(a: u32, b: &str) -> String {\n    format!(\"{b} {a}\")\n}\nmake_string(927, \"label\"); // => \"label 927\"\n```\n\nIt is not valid to put positional parameters (those without names) after\narguments that have names. Like with positional parameters, it is not\nvalid to provide named parameters that are unused by the format string.\n\n# Formatting Parameters\n\nEach argument being formatted can be transformed by a number of formatting\nparameters (corresponding to `format_spec` in [the syntax](#syntax)). These\nparameters affect the string representation of what's being formatted.\n\n## Width\n\n```rust\n// All of these print \"Hello x    !\"\nprintln!(\"Hello {:5}!\", \"x\");\nprintln!(\"Hello {:1$}!\", \"x\", 5);\nprintln!(\"Hello {1:0$}!\", 5, \"x\");\nprintln!(\"Hello {:width$}!\", \"x\", width = 5);\nlet width = 5;\nprintln!(\"Hello {:width$}!\", \"x\");\n```\n\nThis is a parameter for the \"minimum width\" that the format should take up.\nIf the value's string does not fill up this many characters, then the\npadding specified by fill/alignment will be used to take up the required\nspace (see below).\n\nThe value for the width can also be provided as a [`usize`] in the list of\nparameters by adding a postfix `$`, indicating that the second argument is\na [`usize`] specifying the width.\n\nReferring to an argument with the dollar syntax does not affect the \"next\nargument\" counter, so it's usually a good idea to refer to arguments by\nposition, or use named arguments.\n\n## Fill/Alignment\n\n```rust\nassert_eq!(format!(\"Hello {:<5}!\", \"x\"),  \"Hello x    !\");\nassert_eq!(format!(\"Hello {:-<5}!\", \"x\"), \"Hello x----!\");\nassert_eq!(format!(\"Hello {:^5}!\", \"x\"),  \"Hello   x  !\");\nassert_eq!(format!(\"Hello {:>5}!\", \"x\"),  \"Hello     x!\");\n```\n\nThe optional fill character and alignment is provided normally in conjunction with the\n[`width`](#width) parameter. It must be defined before `width`, right after the `:`.\nThis indicates that if the value being formatted is smaller than\n`width` some extra characters will be printed around it.\nFilling comes in the following variants for different alignments:\n\n* `[fill]<` - the argument is left-aligned in `width` columns\n* `[fill]^` - the argument is center-aligned in `width` columns\n* `[fill]>` - the argument is right-aligned in `width` columns\n\nThe default [fill/alignment](#fillalignment) for non-numerics is a space and\nleft-aligned. The\ndefault for numeric formatters is also a space character but with right-alignment. If\nthe `0` flag (see below) is specified for numerics, then the implicit fill character is\n`0`.\n\nNote that alignment might not be implemented by some types. In particular, it\nis not generally implemented for the `Debug` trait.  A good way to ensure\npadding is applied is to format your input, then pad this resulting string\nto obtain your output:\n\n```rust\nprintln!(\"Hello {:^15}!\", format!(\"{:?}\", Some(\"hi\"))); // => \"Hello   Some(\"hi\")   !\"\n```\n\n## Sign/`#`/`0`\n\n```rust\nassert_eq!(format!(\"Hello {:+}!\", 5), \"Hello +5!\");\nassert_eq!(format!(\"{:#x}!\", 27), \"0x1b!\");\nassert_eq!(format!(\"Hello {:05}!\", 5),  \"Hello 00005!\");\nassert_eq!(format!(\"Hello {:05}!\", -5), \"Hello -0005!\");\nassert_eq!(format!(\"{:#010x}!\", 27), \"0x0000001b!\");\n```\n\nThese are all flags altering the behavior of the formatter.\n\n* `+` - This is intended for numeric types and indicates that the sign\n        should always be printed. Positive signs are never printed by\n        default, and the negative sign is only printed by default for signed values.\n        This flag indicates that the correct sign (`+` or `-`) should always be printed.\n* `-` - Currently not used\n* `#` - This flag indicates that the \"alternate\" form of printing should\n        be used. The alternate forms are:\n    * `#?` - pretty-print the [`Debug`] formatting (adds linebreaks and indentation)\n    * `#x` - precedes the argument with a `0x`\n    * `#X` - precedes the argument with a `0x`\n    * `#b` - precedes the argument with a `0b`\n    * `#o` - precedes the argument with a `0o`\n* `0` - This is used to indicate for integer formats that the padding to `width` should\n        both be done with a `0` character as well as be sign-aware. A format\n        like `{:08}` would yield `00000001` for the integer `1`, while the\n        same format would yield `-0000001` for the integer `-1`. Notice that\n        the negative version has one fewer zero than the positive version.\n        Note that padding zeros are always placed after the sign (if any)\n        and before the digits. When used together with the `#` flag, a similar\n        rule applies: padding zeros are inserted after the prefix but before\n        the digits. The prefix is included in the total width.\n\n## Precision\n\nFor non-numeric types, this can be considered a \"maximum width\". If the resulting string is\nlonger than this width, then it is truncated down to this many characters and that truncated\nvalue is emitted with proper `fill`, `alignment` and `width` if those parameters are set.\n\nFor integral types, this is ignored.\n\nFor floating-point types, this indicates how many digits after the decimal point should be\nprinted.\n\nThere are three possible ways to specify the desired `precision`:\n\n1. An integer `.N`:\n\n   the integer `N` itself is the precision.\n\n2. An integer or name followed by dollar sign `.N$`:\n\n   use format *argument* `N` (which must be a `usize`) as the precision.\n\n3. An asterisk `.*`:\n\n   `.*` means that this `{...}` is associated with *two* format inputs rather than one: the\n   first input holds the `usize` precision, and the second holds the value to print. Note that\n   in this case, if one uses the format string `{<arg>:<spec>.*}`, then the `<arg>` part refers\n   to the *value* to print, and the `precision` must come in the input preceding `<arg>`.\n\nFor example, the following calls all print the same thing `Hello x is 0.01000`:\n\n```rust\n// Hello {arg 0 (\"x\")} is {arg 1 (0.01) with precision specified inline (5)}\nprintln!(\"Hello {0} is {1:.5}\", \"x\", 0.01);\n\n// Hello {arg 1 (\"x\")} is {arg 2 (0.01) with precision specified in arg 0 (5)}\nprintln!(\"Hello {1} is {2:.0$}\", 5, \"x\", 0.01);\n\n// Hello {arg 0 (\"x\")} is {arg 2 (0.01) with precision specified in arg 1 (5)}\nprintln!(\"Hello {0} is {2:.1$}\", \"x\", 5, 0.01);\n\n// Hello {next arg (\"x\")} is {second of next two args (0.01) with precision\n//                          specified in first of next two args (5)}\nprintln!(\"Hello {} is {:.*}\",    \"x\", 5, 0.01);\n\n// Hello {next arg (\"x\")} is {arg 2 (0.01) with precision\n//                          specified in its predecessor (5)}\nprintln!(\"Hello {} is {2:.*}\",   \"x\", 5, 0.01);\n\n// Hello {next arg (\"x\")} is {arg \"number\" (0.01) with precision specified\n//                          in arg \"prec\" (5)}\nprintln!(\"Hello {} is {number:.prec$}\", \"x\", prec = 5, number = 0.01);\n```\n\nWhile these:\n\n```rust\nprintln!(\"{}, `{name:.*}` has 3 fractional digits\", \"Hello\", 3, name=1234.56);\nprintln!(\"{}, `{name:.*}` has 3 characters\", \"Hello\", 3, name=\"1234.56\");\nprintln!(\"{}, `{name:>8.*}` has 3 right-aligned characters\", \"Hello\", 3, name=\"1234.56\");\n```\n\nprint three significantly different things:\n\n```text\nHello, `1234.560` has 3 fractional digits\nHello, `123` has 3 characters\nHello, `     123` has 3 right-aligned characters\n```\n\n## Localization\n\nIn some programming languages, the behavior of string formatting functions\ndepends on the operating system's locale setting. The format functions\nprovided by Rust's standard library do not have any concept of locale and\nwill produce the same results on all systems regardless of user\nconfiguration.\n\nFor example, the following code will always print `1.5` even if the system\nlocale uses a decimal separator other than a dot.\n\n```rust\nprintln!(\"The value is {}\", 1.5);\n```\n\n# Escaping\n\nThe literal characters `{` and `}` may be included in a string by preceding\nthem with the same character. For example, the `{` character is escaped with\n`{{` and the `}` character is escaped with `}}`.\n\n```rust\nassert_eq!(format!(\"Hello {{}}\"), \"Hello {}\");\nassert_eq!(format!(\"{{ Hello\"), \"{ Hello\");\n```\n\n# Syntax\n\nTo summarize, here you can find the full grammar of format strings.\nThe syntax for the formatting language used is drawn from other languages,\nso it should not be too alien. Arguments are formatted with Python-like\nsyntax, meaning that arguments are surrounded by `{}` instead of the C-like\n`%`. The actual grammar for the formatting syntax is:\n\n```text\nformat_string := text [ maybe_format text ] *\nmaybe_format := '{' '{' | '}' '}' | format\nformat := '{' [ argument ] [ ':' format_spec ] '}'\nargument := integer | identifier\n\nformat_spec := [[fill]align][sign]['#']['0'][width]['.' precision]type\nfill := character\nalign := '<' | '^' | '>'\nsign := '+' | '-'\nwidth := count\nprecision := count | '*'\ntype := '' | '?' | 'x?' | 'X?' | identifier\ncount := parameter | integer\nparameter := argument '$'\n```\nIn the above grammar, `text` must not contain any `'{'` or `'}'` characters.\n\n# Formatting traits\n\nWhen requesting that an argument be formatted with a particular type, you\nare actually requesting that an argument ascribes to a particular trait.\nThis allows multiple actual types to be formatted via `{:x}` (like [`i8`] as\nwell as [`isize`]). The current mapping of types to traits is:\n\n* *nothing* ⇒ [`Display`]\n* `?` ⇒ [`Debug`]\n* `x?` ⇒ [`Debug`] with lower-case hexadecimal integers\n* `X?` ⇒ [`Debug`] with upper-case hexadecimal integers\n* `o` ⇒ [`Octal`]\n* `x` ⇒ [`LowerHex`]\n* `X` ⇒ [`UpperHex`]\n* `p` ⇒ [`Pointer`]\n* `b` ⇒ [`Binary`]\n* `e` ⇒ [`LowerExp`]\n* `E` ⇒ [`UpperExp`]\n\nWhat this means is that any type of argument which implements the\n[`fmt::Binary`][`Binary`] trait can then be formatted with `{:b}`. Implementations\nare provided for these traits for a number of primitive types by the\nstandard library as well. If no format is specified (as in `{}` or `{:6}`),\nthen the format trait used is the [`Display`] trait.\n\nWhen implementing a format trait for your own type, you will have to\nimplement a method of the signature:\n\n```rust\nfn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n```\n\nYour type will be passed as `self` by-reference, and then the function\nshould emit output into the `f.buf` stream. It is up to each format trait\nimplementation to correctly adhere to the requested formatting parameters.\nThe values of these parameters will be listed in the fields of the\n[`Formatter`] struct. In order to help with this, the [`Formatter`] struct also\nprovides some helper methods.\n\nAdditionally, the return value of this function is [`fmt::Result`] which is a\ntype alias of <code>[Result]<(), [std::fmt::Error]></code>. Formatting implementations\nshould ensure that they propagate errors from the [`Formatter`] (e.g., when\ncalling [`write!`]). However, they should never return errors spuriously. That\nis, a formatting implementation must and may only return an error if the\npassed-in [`Formatter`] returns an error. This is because, contrary to what\nthe function signature might suggest, string formatting is an infallible\noperation. This function only returns a result because writing to the\nunderlying stream might fail and it must provide a way to propagate the fact\nthat an error has occurred back up the stack.\n\nAn example of implementing the formatting traits would look\nlike:\n\n```rust\nuse std::fmt;\n\n#[derive(Debug)]\nstruct Vector2D {\n    x: isize,\n    y: isize,\n}\n\nimpl fmt::Display for Vector2D {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        // The `f` value implements the `Write` trait, which is what the\n        // write! macro is expecting. Note that this formatting ignores the\n        // various flags provided to format strings.\n        write!(f, \"({}, {})\", self.x, self.y)\n    }\n}\n\n// Different traits allow different forms of output of a type. The meaning\n// of this format is to print the magnitude of a vector.\nimpl fmt::Binary for Vector2D {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        let magnitude = (self.x * self.x + self.y * self.y) as f64;\n        let magnitude = magnitude.sqrt();\n\n        // Respect the formatting flags by using the helper method\n        // `pad_integral` on the Formatter object. See the method\n        // documentation for details, and the function `pad` can be used\n        // to pad strings.\n        let decimals = f.precision().unwrap_or(3);\n        let string = format!(\"{:.*}\", decimals, magnitude);\n        f.pad_integral(true, \"\", &string)\n    }\n}\n\nfn main() {\n    let myvector = Vector2D { x: 3, y: 4 };\n\n    println!(\"{myvector}\");       // => \"(3, 4)\"\n    println!(\"{myvector:?}\");     // => \"Vector2D {x: 3, y:4}\"\n    println!(\"{myvector:10.3b}\"); // => \"     5.000\"\n}\n```\n\n### `fmt::Display` vs `fmt::Debug`\n\nThese two formatting traits have distinct purposes:\n\n- [`fmt::Display`][`Display`] implementations assert that the type can be faithfully\n  represented as a UTF-8 string at all times. It is **not** expected that\n  all types implement the [`Display`] trait.\n- [`fmt::Debug`][`Debug`] implementations should be implemented for **all** public types.\n  Output will typically represent the internal state as faithfully as possible.\n  The purpose of the [`Debug`] trait is to facilitate debugging Rust code. In\n  most cases, using `#[derive(Debug)]` is sufficient and recommended.\n\nSome examples of the output from both traits:\n\n```rust\nassert_eq!(format!(\"{} {:?}\", 3, 4), \"3 4\");\nassert_eq!(format!(\"{} {:?}\", 'a', 'b'), \"a 'b'\");\nassert_eq!(format!(\"{} {:?}\", \"foo\\n\", \"bar\\n\"), \"foo\\n \\\"bar\\\\n\\\"\");\n```\n\n# Related macros\n\nThere are a number of related macros in the [`format!`] family. The ones that\nare currently implemented are:\n\n```rust\nformat!      // described above\nwrite!       // first argument is a &mut io::Write, the destination\nwriteln!     // same as write but appends a newline\nprint!       // the format string is printed to the standard output\nprintln!     // same as print but appends a newline\neprint!      // the format string is printed to the standard error\neprintln!    // same as eprint but appends a newline\nformat_args! // described below.\n```\n\n### `write!`\n\nThis and [`writeln!`] are two macros which are used to emit the format string\nto a specified stream. This is used to prevent intermediate allocations of\nformat strings and instead directly write the output. Under the hood, this\nfunction is actually invoking the [`write_fmt`] function defined on the\n[`std::io::Write`] trait. Example usage is:\n\n```rust\nuse std::io::Write;\nlet mut w = Vec::new();\nwrite!(&mut w, \"Hello {}!\", \"world\");\n```\n\n### `print!`\n\nThis and [`println!`] emit their output to stdout. Similarly to the [`write!`]\nmacro, the goal of these macros is to avoid intermediate allocations when\nprinting output. Example usage is:\n\n```rust\nprint!(\"Hello {}!\", \"world\");\nprintln!(\"I have a newline {}\", \"character at the end\");\n```\n### `eprint!`\n\nThe [`eprint!`] and [`eprintln!`] macros are identical to\n[`print!`] and [`println!`], respectively, except they emit their\noutput to stderr.\n\n### `format_args!`\n\nThis is a curious macro used to safely pass around\nan opaque object describing the format string. This object\ndoes not require any heap allocations to create, and it only\nreferences information on the stack. Under the hood, all of\nthe related macros are implemented in terms of this. First\noff, some example usage is:\n\n```rust\nuse std::fmt;\nuse std::io::{self, Write};\n\nlet mut some_writer = io::stdout();\nwrite!(&mut some_writer, \"{}\", format_args!(\"print with a {}\", \"macro\"));\n\nfn my_fmt_fn(args: fmt::Arguments) {\n    write!(&mut io::stdout(), \"{}\", args);\n}\nmy_fmt_fn(format_args!(\", or a {} too\", \"function\"));\n```\n\nThe result of the [`format_args!`] macro is a value of type [`fmt::Arguments`].\nThis structure can then be passed to the [`write`] and [`format`] functions\ninside this module in order to process the format string.\nThe goal of this macro is to even further prevent intermediate allocations\nwhen dealing with formatting strings.\n\nFor example, a logging library could use the standard formatting syntax, but\nit would internally pass around this structure until it has been determined\nwhere output should go to.\n\n[`fmt::Result`]: Result \"fmt::Result\"\n[Result]: core::result::Result \"std::result::Result\"\n[std::fmt::Error]: Error \"fmt::Error\"\n[`write`]: write() \"fmt::write\"\n[`to_string`]: crate::string::ToString::to_string \"ToString::to_string\"\n[`write_fmt`]: ../../std/io/trait.Write.html#method.write_fmt\n[`std::io::Write`]: ../../std/io/trait.Write.html\n[`print!`]: ../../std/macro.print.html \"print!\"\n[`println!`]: ../../std/macro.println.html \"println!\"\n[`eprint!`]: ../../std/macro.eprint.html \"eprint!\"\n[`eprintln!`]: ../../std/macro.eprintln.html \"eprintln!\"\n[`fmt::Arguments`]: Arguments \"fmt::Arguments\"\n[`format`]: format() \"fmt::format\""          },          filterText = "fmt",          kind = 9,          label = "fmt",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2923              },              start = {                character = 6,                line = 2923              }            },            newText = "fmt",            replace = {              end = {                character = 13,                line = 2923              },              start = {                character = 6,                line = 2923              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "abstract_prototypes",          kind = 9,          label = "abstract_prototypes",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2923              },              start = {                character = 6,                line = 2923              }            },            newText = "abstract_prototypes",            replace = {              end = {                character = 13,                line = 2923              },              start = {                character = 6,                line = 2923              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "prototype_type",          kind = 9,          label = "prototype_type",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2923              },              start = {                character = 6,                line = 2923              }            },            newText = "prototype_type",            replace = {              end = {                character = 13,                line = 2923              },              start = {                character = 6,                line = 2923              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "additional_types",          kind = 9,          label = "additional_types",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2923              },              start = {                character = 6,                line = 2923              }            },            newText = "additional_types",            replace = {              end = {                character = 13,                line = 2923              },              start = {                character = 6,                line = 2923              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "utility",          kind = 9,          label = "utility",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2923              },              start = {                character = 6,                line = 2923              }            },            newText = "utility",            replace = {              end = {                character = 13,                line = 2923              },              start = {                character = 6,                line = 2923              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "Extra iterator adaptors, functions and macros.\n\nTo extend [`Iterator`] with methods in this crate, import\nthe [`Itertools`] trait:\n\n```rust\nuse itertools::Itertools;\n```\n\nNow, new methods like [`interleave`](Itertools::interleave)\nare available on all iterators:\n\n```rust\nuse itertools::Itertools;\n\nlet it = (1..3).interleave(vec![-1, -2]);\nitertools::assert_equal(it, vec![1, -1, 2, -2]);\n```\n\nMost iterator methods are also provided as functions (with the benefit\nthat they convert parameters using [`IntoIterator`]):\n\n```rust\nuse itertools::interleave;\n\nfor elt in interleave(&[1, 2, 3], &[2, 3, 4]) {\n    /* loop body */\n}\n```\n\n## Crate Features\n\n- `use_std`\n  - Enabled by default.\n  - Disable to compile itertools using `#![no_std]`. This disables\n    any items that depend on collections (like `group_by`, `unique`,\n    `kmerge`, `join` and many more).\n\n## Rust Version\n\nThis version of itertools requires Rust 1.32 or later."          },          filterText = "itertools",          kind = 9,          label = "itertools",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2923              },              start = {                character = 6,                line = 2923              }            },            newText = "itertools",            replace = {              end = {                character = 13,                line = 2923              },              start = {                character = 6,                line = 2923              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "# High-level bindings to Lua\n\nThe `mlua` crate provides safe high-level bindings to the [Lua programming language].\n\n# The `Lua` object\n\nThe main type exported by this library is the [`Lua`] struct. In addition to methods for\n[executing] Lua chunks or [evaluating] Lua expressions, it provides methods for creating Lua\nvalues and accessing the table of [globals].\n\n# Converting data\n\nThe [`ToLua`] and [`FromLua`] traits allow conversion from Rust types to Lua values and vice\nversa. They are implemented for many data structures found in Rust's standard library.\n\nFor more general conversions, the [`ToLuaMulti`] and [`FromLuaMulti`] traits allow converting\nbetween Rust types and *any number* of Lua values.\n\nMost code in `mlua` is generic over implementors of those traits, so in most places the normal\nRust data structures are accepted without having to write any boilerplate.\n\n# Custom Userdata\n\nThe [`UserData`] trait can be implemented by user-defined types to make them available to Lua.\nMethods and operators to be used from Lua can be added using the [`UserDataMethods`] API.\nFields are supported using the [`UserDataFields`] API.\n\n# Serde support\n\nThe [`LuaSerdeExt`] trait implemented for [`Lua`] allows conversion from Rust types to Lua values\nand vice versa using serde. Any user defined data type that implements [`serde::Serialize`] or\n[`serde::Deserialize`] can be converted.\nFor convenience, additional functionality to handle `NULL` values and arrays is provided.\n\nThe [`Value`] enum implements [`serde::Serialize`] trait to support serializing Lua values\n(including [`UserData`]) into Rust values.\n\nRequires `feature = \"serialize\"`.\n\n# Async/await support\n\nThe [`create_async_function`] allows creating non-blocking functions that returns [`Future`].\nLua code with async capabilities can be executed by [`call_async`] family of functions or polling\n[`AsyncThread`] using any runtime (eg. Tokio).\n\nRequires `feature = \"async\"`.\n\n# `Send` requirement\nBy default `mlua` is `!Send`. This can be changed by enabling `feature = \"send\"` that adds `Send` requirement\nto [`Function`]s and [`UserData`].\n\n[Lua programming language]: https://www.lua.org/\n[`Lua`]: crate::Lua\n[executing]: crate::Chunk::exec\n[evaluating]: crate::Chunk::eval\n[globals]: crate::Lua::globals\n[`ToLua`]: crate::ToLua\n[`FromLua`]: crate::FromLua\n[`ToLuaMulti`]: crate::ToLuaMulti\n[`FromLuaMulti`]: crate::FromLuaMulti\n[`Function`]: crate::Function\n[`UserData`]: crate::UserData\n[`UserDataFields`]: crate::UserDataFields\n[`UserDataMethods`]: crate::UserDataMethods\n[`LuaSerdeExt`]: crate::LuaSerdeExt\n[`Value`]: crate::Value\n[`create_async_function`]: crate::Lua::create_async_function\n[`call_async`]: crate::Function::call_async\n[`AsyncThread`]: crate::AsyncThread\n[`Future`]: std::future::Future\n[`serde::Serialize`]: https://docs.serde.rs/serde/ser/trait.Serialize.html\n[`serde::Deserialize`]: https://docs.serde.rs/serde/de/trait.Deserialize.html"          },          filterText = "mlua",          kind = 9,          label = "mlua",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2923              },              start = {                character = 6,                line = 2923              }            },            newText = "mlua",            replace = {              end = {                character = 13,                line = 2923              },              start = {                character = 6,                line = 2923              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "# The Rust core allocation and collections library\n\nThis library provides smart pointers and collections for managing\nheap-allocated values.\n\nThis library, like libcore, normally doesn’t need to be used directly\nsince its contents are re-exported in the [`std` crate](../std/index.html).\nCrates that use the `#![no_std]` attribute however will typically\nnot depend on `std`, so they’d use this crate instead.\n\n## Boxed values\n\nThe [`Box`] type is a smart pointer type. There can only be one owner of a\n[`Box`], and the owner can decide to mutate the contents, which live on the\nheap.\n\nThis type can be sent among threads efficiently as the size of a `Box` value\nis the same as that of a pointer. Tree-like data structures are often built\nwith boxes because each node often has only one owner, the parent.\n\n## Reference counted pointers\n\nThe [`Rc`] type is a non-threadsafe reference-counted pointer type intended\nfor sharing memory within a thread. An [`Rc`] pointer wraps a type, `T`, and\nonly allows access to `&T`, a shared reference.\n\nThis type is useful when inherited mutability (such as using [`Box`]) is too\nconstraining for an application, and is often paired with the [`Cell`] or\n[`RefCell`] types in order to allow mutation.\n\n## Atomically reference counted pointers\n\nThe [`Arc`] type is the threadsafe equivalent of the [`Rc`] type. It\nprovides all the same functionality of [`Rc`], except it requires that the\ncontained type `T` is shareable. Additionally, [`Arc<T>`][`Arc`] is itself\nsendable while [`Rc<T>`][`Rc`] is not.\n\nThis type allows for shared access to the contained data, and is often\npaired with synchronization primitives such as mutexes to allow mutation of\nshared resources.\n\n## Collections\n\nImplementations of the most common general purpose data structures are\ndefined in this library. They are re-exported through the\n[standard collections library](../std/collections/index.html).\n\n## Heap interfaces\n\nThe [`alloc`](alloc/index.html) module defines the low-level interface to the\ndefault global allocator. It is not compatible with the libc allocator API.\n\n[`Arc`]: sync\n[`Box`]: boxed\n[`Cell`]: core::cell\n[`Rc`]: rc\n[`RefCell`]: core::cell"          },          filterText = "alloc",          kind = 9,          label = "alloc",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2923              },              start = {                character = 6,                line = 2923              }            },            newText = "alloc",            replace = {              end = {                character = 13,                line = 2923              },              start = {                character = 6,                line = 2923              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "This crate is not intended for use outside of [factorio-lib-rs]!"          },          filterText = "factorio_lib_rs_derive",          kind = 9,          label = "factorio_lib_rs_derive",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2923              },              start = {                character = 6,                line = 2923              }            },            newText = "factorio_lib_rs_derive",            replace = {              end = {                character = 13,                line = 2923              },              start = {                character = 6,                line = 2923              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = " Compile-time string formatting.\n\n This crate provides types and macros for formatting strings at compile-time.\n\n # Rust versions\n\n There are some features that require Rust 1.46.0,\n some that require Rust 1.51.0,\n and others that require Rust nightly,\n the sections below describe the features that are available for each version.\n\n ### Rust 1.46.0\n\n These macros are the only things available in Rust 1.46.0:\n\n - [`concatcp`]:\n Concatenates `integers`, `bool`, `char`, and `&str` constants into a `&'static str` constant.\n\n - [`formatcp`]:\n [`format`]-like formatting which takes `integers`, `bool`, `char`, and `&str` constants,\n and emits a `&'static str` constant.\n\n - [`str_get`]:\n Indexes a `&'static str` constant, returning `None` when the index is out of bounds.\n\n - [`str_index`]:\n Indexes a `&'static str` constant.\n\n - [`str_repeat`]:\n Creates a `&'static str` by repeating a `&'static str` constant `times` times.\n\n - [`str_splice`]:\n Replaces a substring in a `&'static str` constant.\n\n\n ### Rust 1.51.0\n\n By enabling the \"const_generics\" feature, you can use these macros:\n\n - [`map_ascii_case`]:\n Converts a `&'static str` constant to a different casing style,\n determined by a [`Case`] argument.\n\n - [`str_replace`]:\n Replaces all the instances of a pattern in a `&'static str` constant with\n another `&'static str` constant.\n\n ### Rust 1.57.0\n\n The \"assertcp\" feature enables the [`assertcp`], [`assertcp_eq`],\n and [`assertcp_ne`] macros.\n These macros are like the standard library assert macros,\n but evaluated at compile-time,\n with the limitation that they can only have primitive types as arguments\n (just like [`concatcp`] and [`formatcp`]).\n\n ### Rust nightly\n\n By enabling the \"fmt\" feature, you can use a [`std::fmt`]-like API.\n\n This requires the nightly compiler because it uses mutable references in const fn,\n which have not been stabilized as of writing these docs.\n\n All the other features of this crate are implemented on top of the [`const_format::fmt`] API:\n\n - [`concatc`]:\n Concatenates many standard library and user defined types into a `&'static str` constant.\n\n - [`formatc`]:\n [`format`]-like macro that can format many standard library and user defined types into\n a `&'static str` constant.\n\n - [`writec`]:\n [`write`]-like macro that can format many standard library and user defined types\n into a type that implements [`WriteMarker`].\n\n The \"derive\" feature enables the [`ConstDebug`] macro,\n and the \"fmt\" feature.<br>\n [`ConstDebug`] derives the [`FormatMarker`] trait,\n and implements an inherent `const_debug_fmt` method for compile-time debug formatting.\n\n The \"assertc\" feature enables the [`assertc`], [`assertc_eq`], [`assertc_ne`] macros,\n and the \"fmt\" feature.<br>\n These macros are like the standard library assert macros, but evaluated at compile-time.\n # Examples\n\n ### Concatenation of primitive types\n\n This example works in Rust 1.46.0.\n\n ```rust\n use const_format::concatcp;\n\n const NAME: &str = \"Bob\";\n const FOO: &str = concatcp!(NAME, \", age \", 21u8,\"!\");\n\n assert_eq!(FOO, \"Bob, age 21!\");\n ```\n\n ### Formatting primitive types\n\n This example works in Rust 1.46.0.\n\n ```rust\n use const_format::formatcp;\n\n const NAME: &str = \"John\";\n\n const FOO: &str = formatcp!(\"{NAME}, age {}!\", compute_age(NAME));\n\n assert_eq!(FOO, \"John, age 24!\");\n\n # const fn compute_age(s: &str) -> usize { s.len() * 6 }\n\n ```\n\n ### Formatting custom types\n\n This example demonstrates how you can use the [`ConstDebug`] derive macro,\n and then format the type into a `&'static str` constant.\n\n This example requires Rust nightly, and the \"derive\" feature.\n\n```rust\n #![feature(const_mut_refs)]\n\n use const_format::{ConstDebug, formatc};\n\n #[derive(ConstDebug)]\n struct Message{\n     ip: [Octet; 4],\n     value: &'static str,\n }\n\n #[derive(ConstDebug)]\n struct Octet(u8);\n\n const MSG: Message = Message{\n     ip: [Octet(127), Octet(0), Octet(0), Octet(1)],\n     value: \"Hello, World!\",\n };\n\n const FOO: &str = formatc!(\"{:?}\", MSG);\n\n assert_eq!(\n     FOO,\n     \"Message { ip: [Octet(127), Octet(0), Octet(0), Octet(1)], value: \\\"Hello, World!\\\" }\"\n );\n\n ```\n\n## Formatted const assertions\n\n This example demonstrates how you can use the [`assertcp_ne`] macro to\n do compile-time inequality assertions with formatted error messages.\n\n This requires the \"assertcp\" feature,\n because using the `panic` macro at compile-time requires Rust 1.57.0.\n\n```ignore\n #![feature(const_mut_refs)]\n\n use const_format::assertcp_ne;\n\n macro_rules! check_valid_pizza{\n     ($user:expr, $topping:expr) => {\n         assertcp_ne!(\n             $topping,\n             \"pineapple\",\n             \"You can't put pineapple on pizza, {}\",\n             $user,\n         );\n     }\n }\n\n check_valid_pizza!(\"John\", \"salami\");\n check_valid_pizza!(\"Dave\", \"sausage\");\n check_valid_pizza!(\"Bob\", \"pineapple\");\n\n # fn main(){}\n ```\n\n This is the compiler output:\n\n ```text\n error[E0080]: evaluation of constant value failed\n   --> src/lib.rs:178:27\n    |\n 20 | check_valid_pizza!(\"Bob\", \"pineapple\");\n    |                           ^^^^^^^^^^^ the evaluated program panicked at '\n assertion failed: `(left != right)`\n  left: `\"pineapple\"`\n right: `\"pineapple\"`\n You can't put pineapple on pizza, Bob\n ', src/lib.rs:20:27\n\n\n ```\n\n <div id=\"macro-limitations\"></div>\n\n # Limitations\n\n All of the macros from `const_format` have these limitations:\n\n - The formatting macros that expand to\n `&'static str`s can only use constants from concrete types,\n so while a `Type::<u8>::FOO` argument would be fine,\n `Type::<T>::FOO` would not be (`T` being a type parameter).\n\n - Integer arguments must have a type inferrable from context,\n [more details in the Integer arguments section](#integer-args).\n\n - They cannot be used places that take string literals.\n So `#[doc = \"foobar\"]` cannot be replaced with `#[doc = concatcp!(\"foo\", \"bar\") ]`.\n\n <span id=\"integer-args\"></span>\n\n ### Integer arguments\n\n Integer arguments must have a type inferrable from context.\n so if you only pass an integer literal it must have a suffix.\n\n Example of what does compile:\n\n ```rust\n const N: u32 = 1;\n assert_eq!(const_format::concatcp!(N + 1, 2 + N), \"23\");\n\n assert_eq!(const_format::concatcp!(2u32, 2 + 1u8, 3u8 + 1), \"234\");\n ```\n\n Example of what does not compile:\n ```compile_fail\n assert_eq!(const_format::concatcp!(1 + 1, 2 + 1), \"23\");\n ```\n\n # Renaming crate\n\n All function-like macros from `const_format` can be used when the crate is renamed.\n\n The [`ConstDebug`] derive macro has the `#[cdeb(crate = \"foo::bar\")]` attribute to\n tell it where to find the `const_format` crate.\n\n Example of renaming the `const_format` crate in the Cargo.toml file:\n ```toml\n cfmt = {version = \"0.*\", package = \"const_format\"}\n ```\n\n # Cargo features\n\n - \"fmt\": Enables the [`std::fmt`]-like API,\n requires Rust nightly because it uses mutable references in const fn.<br>\n This feature includes the [`formatc`]/[`writec`] formatting macros.\n\n - \"derive\": implies the \"fmt\" feature,\n provides the [`ConstDebug`] derive macro to format user-defined types at compile-time.<br>\n This implicitly uses the `syn` crate, so clean compiles take a bit longer than without the feature.\n\n - \"assertc\": implies the \"fmt\" feature,\n enables the [`assertc`], [`assertc_eq`], and [`assertc_ne`] assertion macros.<br>\n This feature was previously named \"assert\",\n but it was renamed to avoid confusion with the \"assertcp\" feature.\n\n - \"assertcp\": Requires Rust 1.57.0, implies the \"const_generics\" feature.\n Enables the [`assertcp`], [`assertcp_eq`], and [`assertcp_ne`] assertion macros.\n\n - \"constant_time_as_str\": implies the \"fmt\" feature.\n An optimization that requires a few additional nightly features,\n allowing the `as_bytes_alt` methods and `slice_up_to_len_alt` methods to run\n in constant time, rather than linear time proportional to the truncated part of the slice.\n\n - \"const_generics\": Requires Rust 1.51.0.\n Enables the macros listed in the [Rust 1.51.0](#rust-1510) section.\n Also changes the the implementation of the [`concatcp`] and [`formatcp`]\n macros to use const generics.\n\n\n\n # No-std support\n\n `const_format` is unconditionally `#![no_std]`, it can be used anywhere Rust can be used.\n\n # Minimum Supported Rust Version\n\n `const_format` requires Rust 1.46.0, because it uses looping an branching in const contexts.\n\n Features that require newer versions of Rust, or the nightly compiler,\n need to be explicitly enabled with cargo features.\n\n\n [`assertc`]: ./macro.assertc.html\n\n [`assertc_eq`]: ./macro.assertc_eq.html\n\n [`assertc_ne`]: ./macro.assertc_ne.html\n\n [`assertcp`]: ./macro.assertcp.html\n\n [`assertcp_eq`]: ./macro.assertcp_eq.html\n\n [`assertcp_ne`]: ./macro.assertcp_ne.html\n\n [`concatcp`]: ./macro.concatcp.html\n\n [`formatcp`]: ./macro.formatcp.html\n\n [`format`]: https://doc.rust-lang.org/std/macro.format.html\n\n [`std::fmt`]: https://doc.rust-lang.org/std/fmt/index.html\n\n [`const_format::fmt`]: ./fmt/index.html\n\n [`concatc`]: ./macro.concatc.html\n\n [`formatc`]: ./macro.formatc.html\n\n [`writec`]: ./macro.writec.html\n\n [`write`]: https://doc.rust-lang.org/std/macro.write.html\n\n [`Formatter`]: ./fmt/struct.Formatter.html\n\n [`StrWriter`]: ./fmt/struct.StrWriter.html\n\n [`ConstDebug`]: ./derive.ConstDebug.html\n\n [`FormatMarker`]: ./marker_traits/trait.FormatMarker.html\n\n [`WriteMarker`]: ./marker_traits/trait.WriteMarker.html\n\n [`map_ascii_case`]: ./macro.map_ascii_case.html\n\n [`Case`]: ./enum.Case.html\n\n\n [`str_get`]: ./macro.str_get.html\n\n [`str_index`]: ./macro.str_index.html\n\n [`str_repeat`]: ./macro.str_repeat.html\n\n [`str_splice`]: ./macro.str_splice.html\n\n [`str_replace`]: ./macro.str_replace.html\n\n [`str::replace`]: https://doc.rust-lang.org/std/primitive.str.html#method.replace"          },          filterText = "const_format",          kind = 9,          label = "const_format",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2923              },              start = {                character = 6,                line = 2923              }            },            newText = "const_format",            replace = {              end = {                character = 13,                line = 2923              },              start = {                character = 6,                line = 2923              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = 'Ini parser for Rust\n\n```rust\nuse ini::Ini;\n\nlet mut conf = Ini::new();\nconf.with_section(Some("User"))\n    .set("name", "Raspberry树莓")\n    .set("value", "Pi");\nconf.with_section(Some("Library"))\n    .set("name", "Sun Yat-sen U")\n    .set("location", "Guangzhou=world");\nconf.write_to_file("conf.ini").unwrap();\n\nlet i = Ini::load_from_file("conf.ini").unwrap();\nfor (sec, prop) in i.iter() {\n    println!("Section: {:?}", sec);\n    for (k, v) in prop.iter() {\n        println!("{}:{}", k, v);\n    }\n}\n```'          },          filterText = "ini",          kind = 9,          label = "ini",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2923              },              start = {                character = 6,                line = 2923              }            },            newText = "ini",            replace = {              end = {                character = 13,                line = 2923              },              start = {                character = 6,                line = 2923              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "\nThis crate provides a library for parsing, compiling, and executing regular\nexpressions. Its syntax is similar to Perl-style regular expressions, but lacks\na few features like look around and backreferences. In exchange, all searches\nexecute in linear time with respect to the size of the regular expression and\nsearch text.\n\nThis crate's documentation provides some simple examples, describes\n[Unicode support](#unicode) and exhaustively lists the\n[supported syntax](#syntax).\n\nFor more specific details on the API for regular expressions, please see the\ndocumentation for the [`Regex`](struct.Regex.html) type.\n\n# Usage\n\nThis crate is [on crates.io](https://crates.io/crates/regex) and can be\nused by adding `regex` to your dependencies in your project's `Cargo.toml`.\n\n```toml\n[dependencies]\nregex = \"1\"\n```\n\n# Example: find a date\n\nGeneral use of regular expressions in this package involves compiling an\nexpression and then using it to search, split or replace text. For example,\nto confirm that some text resembles a date:\n\n```rust\nuse regex::Regex;\nlet re = Regex::new(r\"^\\d{4}-\\d{2}-\\d{2}$\").unwrap();\nassert!(re.is_match(\"2014-01-01\"));\n```\n\nNotice the use of the `^` and `$` anchors. In this crate, every expression\nis executed with an implicit `.*?` at the beginning and end, which allows\nit to match anywhere in the text. Anchors can be used to ensure that the\nfull text matches an expression.\n\nThis example also demonstrates the utility of\n[raw strings](https://doc.rust-lang.org/stable/reference/tokens.html#raw-string-literals)\nin Rust, which\nare just like regular strings except they are prefixed with an `r` and do\nnot process any escape sequences. For example, `\"\\\\d\"` is the same\nexpression as `r\"\\d\"`.\n\n# Example: Avoid compiling the same regex in a loop\n\nIt is an anti-pattern to compile the same regular expression in a loop\nsince compilation is typically expensive. (It takes anywhere from a few\nmicroseconds to a few **milliseconds** depending on the size of the\nregex.) Not only is compilation itself expensive, but this also prevents\noptimizations that reuse allocations internally to the matching engines.\n\nIn Rust, it can sometimes be a pain to pass regular expressions around if\nthey're used from inside a helper function. Instead, we recommend using the\n[`lazy_static`](https://crates.io/crates/lazy_static) crate to ensure that\nregular expressions are compiled exactly once.\n\nFor example:\n\n```rust\nuse lazy_static::lazy_static;\nuse regex::Regex;\n\nfn some_helper_function(text: &str) -> bool {\n    lazy_static! {\n        static ref RE: Regex = Regex::new(\"...\").unwrap();\n    }\n    RE.is_match(text)\n}\n\nfn main() {}\n```\n\nSpecifically, in this example, the regex will be compiled when it is used for\nthe first time. On subsequent uses, it will reuse the previous compilation.\n\n# Example: iterating over capture groups\n\nThis crate provides convenient iterators for matching an expression\nrepeatedly against a search string to find successive non-overlapping\nmatches. For example, to find all dates in a string and be able to access\nthem by their component pieces:\n\n```rust\nlet re = Regex::new(r\"(\\d{4})-(\\d{2})-(\\d{2})\").unwrap();\nlet text = \"2012-03-14, 2013-01-01 and 2014-07-05\";\nfor cap in re.captures_iter(text) {\n    println!(\"Month: {} Day: {} Year: {}\", &cap[2], &cap[3], &cap[1]);\n}\n// Output:\n// Month: 03 Day: 14 Year: 2012\n// Month: 01 Day: 01 Year: 2013\n// Month: 07 Day: 05 Year: 2014\n```\n\nNotice that the year is in the capture group indexed at `1`. This is\nbecause the *entire match* is stored in the capture group at index `0`.\n\n# Example: replacement with named capture groups\n\nBuilding on the previous example, perhaps we'd like to rearrange the date\nformats. This can be done with text replacement. But to make the code\nclearer, we can *name*  our capture groups and use those names as variables\nin our replacement text:\n\n```rust\nlet re = Regex::new(r\"(?P<y>\\d{4})-(?P<m>\\d{2})-(?P<d>\\d{2})\").unwrap();\nlet before = \"2012-03-14, 2013-01-01 and 2014-07-05\";\nlet after = re.replace_all(before, \"$m/$d/$y\");\nassert_eq!(after, \"03/14/2012, 01/01/2013 and 07/05/2014\");\n```\n\nThe `replace` methods are actually polymorphic in the replacement, which\nprovides more flexibility than is seen here. (See the documentation for\n`Regex::replace` for more details.)\n\nNote that if your regex gets complicated, you can use the `x` flag to\nenable insignificant whitespace mode, which also lets you write comments:\n\n```rust\nlet re = Regex::new(r\"(?x)\n  (?P<y>\\d{4}) # the year\n  -\n  (?P<m>\\d{2}) # the month\n  -\n  (?P<d>\\d{2}) # the day\n\").unwrap();\nlet before = \"2012-03-14, 2013-01-01 and 2014-07-05\";\nlet after = re.replace_all(before, \"$m/$d/$y\");\nassert_eq!(after, \"03/14/2012, 01/01/2013 and 07/05/2014\");\n```\n\nIf you wish to match against whitespace in this mode, you can still use `\\s`,\n`\\n`, `\\t`, etc. For escaping a single space character, you can escape it\ndirectly with `\\ `, use its hex character code `\\x20` or temporarily disable\nthe `x` flag, e.g., `(?-x: )`.\n\n# Example: match multiple regular expressions simultaneously\n\nThis demonstrates how to use a `RegexSet` to match multiple (possibly\noverlapping) regular expressions in a single scan of the search text:\n\n```rust\nuse regex::RegexSet;\n\nlet set = RegexSet::new(&[\n    r\"\\w+\",\n    r\"\\d+\",\n    r\"\\pL+\",\n    r\"foo\",\n    r\"bar\",\n    r\"barfoo\",\n    r\"foobar\",\n]).unwrap();\n\n// Iterate over and collect all of the matches.\nlet matches: Vec<_> = set.matches(\"foobar\").into_iter().collect();\nassert_eq!(matches, vec![0, 2, 3, 4, 6]);\n\n// You can also test whether a particular regex matched:\nlet matches = set.matches(\"foobar\");\nassert!(!matches.matched(5));\nassert!(matches.matched(6));\n```\n\n# Pay for what you use\n\nWith respect to searching text with a regular expression, there are three\nquestions that can be asked:\n\n1. Does the text match this expression?\n2. If so, where does it match?\n3. Where did the capturing groups match?\n\nGenerally speaking, this crate could provide a function to answer only #3,\nwhich would subsume #1 and #2 automatically. However, it can be significantly\nmore expensive to compute the location of capturing group matches, so it's best\nnot to do it if you don't need to.\n\nTherefore, only use what you need. For example, don't use `find` if you\nonly need to test if an expression matches a string. (Use `is_match`\ninstead.)\n\n# Unicode\n\nThis implementation executes regular expressions **only** on valid UTF-8\nwhile exposing match locations as byte indices into the search string. (To\nrelax this restriction, use the [`bytes`](bytes/index.html) sub-module.)\n\nOnly simple case folding is supported. Namely, when matching\ncase-insensitively, the characters are first mapped using the \"simple\" case\nfolding rules defined by Unicode.\n\nRegular expressions themselves are **only** interpreted as a sequence of\nUnicode scalar values. This means you can use Unicode characters directly\nin your expression:\n\n```rust\nlet re = Regex::new(r\"(?i)Δ+\").unwrap();\nlet mat = re.find(\"ΔδΔ\").unwrap();\nassert_eq!((mat.start(), mat.end()), (0, 6));\n```\n\nMost features of the regular expressions in this crate are Unicode aware. Here\nare some examples:\n\n* `.` will match any valid UTF-8 encoded Unicode scalar value except for `\\n`.\n  (To also match `\\n`, enable the `s` flag, e.g., `(?s:.)`.)\n* `\\w`, `\\d` and `\\s` are Unicode aware. For example, `\\s` will match all forms\n  of whitespace categorized by Unicode.\n* `\\b` matches a Unicode word boundary.\n* Negated character classes like `[^a]` match all Unicode scalar values except\n  for `a`.\n* `^` and `$` are **not** Unicode aware in multi-line mode. Namely, they only\n  recognize `\\n` and not any of the other forms of line terminators defined\n  by Unicode.\n\nUnicode general categories, scripts, script extensions, ages and a smattering\nof boolean properties are available as character classes. For example, you can\nmatch a sequence of numerals, Greek or Cherokee letters:\n\n```rust\nlet re = Regex::new(r\"[\\pN\\p{Greek}\\p{Cherokee}]+\").unwrap();\nlet mat = re.find(\"abcΔᎠβⅠᏴγδⅡxyz\").unwrap();\nassert_eq!((mat.start(), mat.end()), (3, 23));\n```\n\nFor a more detailed breakdown of Unicode support with respect to\n[UTS#18](https://unicode.org/reports/tr18/),\nplease see the\n[UNICODE](https://github.com/rust-lang/regex/blob/master/UNICODE.md)\ndocument in the root of the regex repository.\n\n# Opt out of Unicode support\n\nThe `bytes` sub-module provides a `Regex` type that can be used to match\non `&[u8]`. By default, text is interpreted as UTF-8 just like it is with\nthe main `Regex` type. However, this behavior can be disabled by turning\noff the `u` flag, even if doing so could result in matching invalid UTF-8.\nFor example, when the `u` flag is disabled, `.` will match any byte instead\nof any Unicode scalar value.\n\nDisabling the `u` flag is also possible with the standard `&str`-based `Regex`\ntype, but it is only allowed where the UTF-8 invariant is maintained. For\nexample, `(?-u:\\w)` is an ASCII-only `\\w` character class and is legal in an\n`&str`-based `Regex`, but `(?-u:\\xFF)` will attempt to match the raw byte\n`\\xFF`, which is invalid UTF-8 and therefore is illegal in `&str`-based\nregexes.\n\nFinally, since Unicode support requires bundling large Unicode data\ntables, this crate exposes knobs to disable the compilation of those\ndata tables, which can be useful for shrinking binary size and reducing\ncompilation times. For details on how to do that, see the section on [crate\nfeatures](#crate-features).\n\n# Syntax\n\nThe syntax supported in this crate is documented below.\n\nNote that the regular expression parser and abstract syntax are exposed in\na separate crate, [`regex-syntax`](https://docs.rs/regex-syntax).\n\n## Matching one character\n\n<pre class=\"rust\">\n.             any character except new line (includes new line with s flag)\n\\d            digit (\\p{Nd})\n\\D            not digit\n\\pN           One-letter name Unicode character class\n\\p{Greek}     Unicode character class (general category or script)\n\\PN           Negated one-letter name Unicode character class\n\\P{Greek}     negated Unicode character class (general category or script)\n</pre>\n\n### Character classes\n\n<pre class=\"rust\">\n[xyz]         A character class matching either x, y or z (union).\n[^xyz]        A character class matching any character except x, y and z.\n[a-z]         A character class matching any character in range a-z.\n[[:alpha:]]   ASCII character class ([A-Za-z])\n[[:^alpha:]]  Negated ASCII character class ([^A-Za-z])\n[x[^xyz]]     Nested/grouping character class (matching any character except y and z)\n[a-y&&xyz]    Intersection (matching x or y)\n[0-9&&[^4]]   Subtraction using intersection and negation (matching 0-9 except 4)\n[0-9--4]      Direct subtraction (matching 0-9 except 4)\n[a-g~~b-h]    Symmetric difference (matching `a` and `h` only)\n[\\[\\]]        Escaping in character classes (matching [ or ])\n</pre>\n\nAny named character class may appear inside a bracketed `[...]` character\nclass. For example, `[\\p{Greek}[:digit:]]` matches any Greek or ASCII\ndigit. `[\\p{Greek}&&\\pL]` matches Greek letters.\n\nPrecedence in character classes, from most binding to least:\n\n1. Ranges: `a-cd` == `[a-c]d`\n2. Union: `ab&&bc` == `[ab]&&[bc]`\n3. Intersection: `^a-z&&b` == `^[a-z&&b]`\n4. Negation\n\n## Composites\n\n<pre class=\"rust\">\nxy    concatenation (x followed by y)\nx|y   alternation (x or y, prefer x)\n</pre>\n\n## Repetitions\n\n<pre class=\"rust\">\nx*        zero or more of x (greedy)\nx+        one or more of x (greedy)\nx?        zero or one of x (greedy)\nx*?       zero or more of x (ungreedy/lazy)\nx+?       one or more of x (ungreedy/lazy)\nx??       zero or one of x (ungreedy/lazy)\nx{n,m}    at least n x and at most m x (greedy)\nx{n,}     at least n x (greedy)\nx{n}      exactly n x\nx{n,m}?   at least n x and at most m x (ungreedy/lazy)\nx{n,}?    at least n x (ungreedy/lazy)\nx{n}?     exactly n x\n</pre>\n\n## Empty matches\n\n<pre class=\"rust\">\n^     the beginning of text (or start-of-line with multi-line mode)\n$     the end of text (or end-of-line with multi-line mode)\n\\A    only the beginning of text (even with multi-line mode enabled)\n\\z    only the end of text (even with multi-line mode enabled)\n\\b    a Unicode word boundary (\\w on one side and \\W, \\A, or \\z on other)\n\\B    not a Unicode word boundary\n</pre>\n\n## Grouping and flags\n\n<pre class=\"rust\">\n(exp)          numbered capture group (indexed by opening parenthesis)\n(?P&lt;name&gt;exp)  named (also numbered) capture group (allowed chars: [_0-9a-zA-Z.\\[\\]])\n(?:exp)        non-capturing group\n(?flags)       set flags within current group\n(?flags:exp)   set flags for exp (non-capturing)\n</pre>\n\nFlags are each a single character. For example, `(?x)` sets the flag `x`\nand `(?-x)` clears the flag `x`. Multiple flags can be set or cleared at\nthe same time: `(?xy)` sets both the `x` and `y` flags and `(?x-y)` sets\nthe `x` flag and clears the `y` flag.\n\nAll flags are by default disabled unless stated otherwise. They are:\n\n<pre class=\"rust\">\ni     case-insensitive: letters match both upper and lower case\nm     multi-line mode: ^ and $ match begin/end of line\ns     allow . to match \\n\nU     swap the meaning of x* and x*?\nu     Unicode support (enabled by default)\nx     ignore whitespace and allow line comments (starting with `#`)\n</pre>\n\nFlags can be toggled within a pattern. Here's an example that matches\ncase-insensitively for the first part but case-sensitively for the second part:\n\n```rust\nlet re = Regex::new(r\"(?i)a+(?-i)b+\").unwrap();\nlet cap = re.captures(\"AaAaAbbBBBb\").unwrap();\nassert_eq!(&cap[0], \"AaAaAbb\");\n```\n\nNotice that the `a+` matches either `a` or `A`, but the `b+` only matches\n`b`.\n\nMulti-line mode means `^` and `$` no longer match just at the beginning/end of\nthe input, but at the beginning/end of lines:\n\n```rust\nlet re = Regex::new(r\"(?m)^line \\d+\").unwrap();\nlet m = re.find(\"line one\\nline 2\\n\").unwrap();\nassert_eq!(m.as_str(), \"line 2\");\n```\n\nNote that `^` matches after new lines, even at the end of input:\n\n```rust\nlet re = Regex::new(r\"(?m)^\").unwrap();\nlet m = re.find_iter(\"test\\n\").last().unwrap();\nassert_eq!((m.start(), m.end()), (5, 5));\n```\n\nHere is an example that uses an ASCII word boundary instead of a Unicode\nword boundary:\n\n```rust\nlet re = Regex::new(r\"(?-u:\\b).+(?-u:\\b)\").unwrap();\nlet cap = re.captures(\"$$abc$$\").unwrap();\nassert_eq!(&cap[0], \"abc\");\n```\n\n## Escape sequences\n\n<pre class=\"rust\">\n\\*          literal *, works for any punctuation character: \\.+*?()|[]{}^$\n\\a          bell (\\x07)\n\\f          form feed (\\x0C)\n\\t          horizontal tab\n\\n          new line\n\\r          carriage return\n\\v          vertical tab (\\x0B)\n\\123        octal character code (up to three digits) (when enabled)\n\\x7F        hex character code (exactly two digits)\n\\x{10FFFF}  any hex character code corresponding to a Unicode code point\n\\u007F      hex character code (exactly four digits)\n\\u{7F}      any hex character code corresponding to a Unicode code point\n\\U0000007F  hex character code (exactly eight digits)\n\\U{7F}      any hex character code corresponding to a Unicode code point\n</pre>\n\n## Perl character classes (Unicode friendly)\n\nThese classes are based on the definitions provided in\n[UTS#18](https://www.unicode.org/reports/tr18/#Compatibility_Properties):\n\n<pre class=\"rust\">\n\\d     digit (\\p{Nd})\n\\D     not digit\n\\s     whitespace (\\p{White_Space})\n\\S     not whitespace\n\\w     word character (\\p{Alphabetic} + \\p{M} + \\d + \\p{Pc} + \\p{Join_Control})\n\\W     not word character\n</pre>\n\n## ASCII character classes\n\n<pre class=\"rust\">\n[[:alnum:]]    alphanumeric ([0-9A-Za-z])\n[[:alpha:]]    alphabetic ([A-Za-z])\n[[:ascii:]]    ASCII ([\\x00-\\x7F])\n[[:blank:]]    blank ([\\t ])\n[[:cntrl:]]    control ([\\x00-\\x1F\\x7F])\n[[:digit:]]    digits ([0-9])\n[[:graph:]]    graphical ([!-~])\n[[:lower:]]    lower case ([a-z])\n[[:print:]]    printable ([ -~])\n[[:punct:]]    punctuation ([!-/:-@\\[-`{-~])\n[[:space:]]    whitespace ([\\t\\n\\v\\f\\r ])\n[[:upper:]]    upper case ([A-Z])\n[[:word:]]     word characters ([0-9A-Za-z_])\n[[:xdigit:]]   hex digit ([0-9A-Fa-f])\n</pre>\n\n# Crate features\n\nBy default, this crate tries pretty hard to make regex matching both as fast\nas possible and as correct as it can be, within reason. This means that there\nis a lot of code dedicated to performance, the handling of Unicode data and the\nUnicode data itself. Overall, this leads to more dependencies, larger binaries\nand longer compile times.  This trade off may not be appropriate in all cases,\nand indeed, even when all Unicode and performance features are disabled, one\nis still left with a perfectly serviceable regex engine that will work well\nin many cases.\n\nThis crate exposes a number of features for controlling that trade off. Some\nof these features are strictly performance oriented, such that disabling them\nwon't result in a loss of functionality, but may result in worse performance.\nOther features, such as the ones controlling the presence or absence of Unicode\ndata, can result in a loss of functionality. For example, if one disables the\n`unicode-case` feature (described below), then compiling the regex `(?i)a`\nwill fail since Unicode case insensitivity is enabled by default. Instead,\ncallers must use `(?i-u)a` instead to disable Unicode case folding. Stated\ndifferently, enabling or disabling any of the features below can only add or\nsubtract from the total set of valid regular expressions. Enabling or disabling\na feature will never modify the match semantics of a regular expression.\n\nAll features below are enabled by default.\n\n### Ecosystem features\n\n* **std** -\n  When enabled, this will cause `regex` to use the standard library. Currently,\n  disabling this feature will always result in a compilation error. It is\n  intended to add `alloc`-only support to regex in the future.\n\n### Performance features\n\n* **perf** -\n  Enables all performance related features. This feature is enabled by default\n  and will always cover all features that improve performance, even if more\n  are added in the future.\n* **perf-dfa** -\n  Enables the use of a lazy DFA for matching. The lazy DFA is used to compile\n  portions of a regex to a very fast DFA on an as-needed basis. This can\n  result in substantial speedups, usually by an order of magnitude on large\n  haystacks. The lazy DFA does not bring in any new dependencies, but it can\n  make compile times longer.\n* **perf-inline** -\n  Enables the use of aggressive inlining inside match routines. This reduces\n  the overhead of each match. The aggressive inlining, however, increases\n  compile times and binary size.\n* **perf-literal** -\n  Enables the use of literal optimizations for speeding up matches. In some\n  cases, literal optimizations can result in speedups of _several_ orders of\n  magnitude. Disabling this drops the `aho-corasick` and `memchr` dependencies.\n* **perf-cache** -\n  This feature used to enable a faster internal cache at the cost of using\n  additional dependencies, but this is no longer an option. A fast internal\n  cache is now used unconditionally with no additional dependencies. This may\n  change in the future.\n\n### Unicode features\n\n* **unicode** -\n  Enables all Unicode features. This feature is enabled by default, and will\n  always cover all Unicode features, even if more are added in the future.\n* **unicode-age** -\n  Provide the data for the\n  [Unicode `Age` property](https://www.unicode.org/reports/tr44/tr44-24.html#Character_Age).\n  This makes it possible to use classes like `\\p{Age:6.0}` to refer to all\n  codepoints first introduced in Unicode 6.0\n* **unicode-bool** -\n  Provide the data for numerous Unicode boolean properties. The full list\n  is not included here, but contains properties like `Alphabetic`, `Emoji`,\n  `Lowercase`, `Math`, `Uppercase` and `White_Space`.\n* **unicode-case** -\n  Provide the data for case insensitive matching using\n  [Unicode's \"simple loose matches\" specification](https://www.unicode.org/reports/tr18/#Simple_Loose_Matches).\n* **unicode-gencat** -\n  Provide the data for\n  [Unicode general categories](https://www.unicode.org/reports/tr44/tr44-24.html#General_Category_Values).\n  This includes, but is not limited to, `Decimal_Number`, `Letter`,\n  `Math_Symbol`, `Number` and `Punctuation`.\n* **unicode-perl** -\n  Provide the data for supporting the Unicode-aware Perl character classes,\n  corresponding to `\\w`, `\\s` and `\\d`. This is also necessary for using\n  Unicode-aware word boundary assertions. Note that if this feature is\n  disabled, the `\\s` and `\\d` character classes are still available if the\n  `unicode-bool` and `unicode-gencat` features are enabled, respectively.\n* **unicode-script** -\n  Provide the data for\n  [Unicode scripts and script extensions](https://www.unicode.org/reports/tr24/).\n  This includes, but is not limited to, `Arabic`, `Cyrillic`, `Hebrew`,\n  `Latin` and `Thai`.\n* **unicode-segment** -\n  Provide the data necessary to provide the properties used to implement the\n  [Unicode text segmentation algorithms](https://www.unicode.org/reports/tr29/).\n  This enables using classes like `\\p{gcb=Extend}`, `\\p{wb=Katakana}` and\n  `\\p{sb=ATerm}`.\n\n\n# Untrusted input\n\nThis crate can handle both untrusted regular expressions and untrusted\nsearch text.\n\nUntrusted regular expressions are handled by capping the size of a compiled\nregular expression.\n(See [`RegexBuilder::size_limit`](struct.RegexBuilder.html#method.size_limit).)\nWithout this, it would be trivial for an attacker to exhaust your system's\nmemory with expressions like `a{100}{100}{100}`.\n\nUntrusted search text is allowed because the matching engine(s) in this\ncrate have time complexity `O(mn)` (with `m ~ regex` and `n ~ search\ntext`), which means there's no way to cause exponential blow-up like with\nsome other regular expression engines. (We pay for this by disallowing\nfeatures like arbitrary look-ahead and backreferences.)\n\nWhen a DFA is used, pathological cases with exponential state blow-up are\navoided by constructing the DFA lazily or in an \"online\" manner. Therefore,\nat most one new state can be created for each byte of input. This satisfies\nour time complexity guarantees, but can lead to memory growth\nproportional to the size of the input. As a stopgap, the DFA is only\nallowed to store a fixed number of states. When the limit is reached, its\nstates are wiped and continues on, possibly duplicating previous work. If\nthe limit is reached too frequently, it gives up and hands control off to\nanother matching engine with fixed memory requirements.\n(The DFA size limit can also be tweaked. See\n[`RegexBuilder::dfa_size_limit`](struct.RegexBuilder.html#method.dfa_size_limit).)"          },          filterText = "regex",          kind = 9,          label = "regex",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2923              },              start = {                character = 6,                line = 2923              }            },            newText = "regex",            replace = {              end = {                character = 13,                line = 2923              },              start = {                character = 6,                line = 2923              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "# Serde\n\nSerde is a framework for ***ser***ializing and ***de***serializing Rust data\nstructures efficiently and generically.\n\nThe Serde ecosystem consists of data structures that know how to serialize\nand deserialize themselves along with data formats that know how to\nserialize and deserialize other things. Serde provides the layer by which\nthese two groups interact with each other, allowing any supported data\nstructure to be serialized and deserialized using any supported data format.\n\nSee the Serde website <https://serde.rs/> for additional documentation and\nusage examples.\n\n## Design\n\nWhere many other languages rely on runtime reflection for serializing data,\nSerde is instead built on Rust's powerful trait system. A data structure\nthat knows how to serialize and deserialize itself is one that implements\nSerde's `Serialize` and `Deserialize` traits (or uses Serde's derive\nattribute to automatically generate implementations at compile time). This\navoids any overhead of reflection or runtime type information. In fact in\nmany situations the interaction between data structure and data format can\nbe completely optimized away by the Rust compiler, leaving Serde\nserialization to perform the same speed as a handwritten serializer for the\nspecific selection of data structure and data format.\n\n## Data formats\n\nThe following is a partial list of data formats that have been implemented\nfor Serde by the community.\n\n- [JSON], the ubiquitous JavaScript Object Notation used by many HTTP APIs.\n- [Bincode], a compact binary format\n  used for IPC within the Servo rendering engine.\n- [CBOR], a Concise Binary Object Representation designed for small message\n  size without the need for version negotiation.\n- [YAML], a self-proclaimed human-friendly configuration language that ain't\n  markup language.\n- [MessagePack], an efficient binary format that resembles a compact JSON.\n- [TOML], a minimal configuration format used by [Cargo].\n- [Pickle], a format common in the Python world.\n- [RON], a Rusty Object Notation.\n- [BSON], the data storage and network transfer format used by MongoDB.\n- [Avro], a binary format used within Apache Hadoop, with support for schema\n  definition.\n- [JSON5], a superset of JSON including some productions from ES5.\n- [Postcard], a no\\_std and embedded-systems friendly compact binary format.\n- [URL] query strings, in the x-www-form-urlencoded format.\n- [Envy], a way to deserialize environment variables into Rust structs.\n  *(deserialization only)*\n- [Envy Store], a way to deserialize [AWS Parameter Store] parameters into\n  Rust structs. *(deserialization only)*\n- [S-expressions], the textual representation of code and data used by the\n  Lisp language family.\n- [D-Bus]'s binary wire format.\n- [FlexBuffers], the schemaless cousin of Google's FlatBuffers zero-copy serialization format.\n- [DynamoDB Items], the format used by [rusoto_dynamodb] to transfer data to\n  and from DynamoDB.\n\n[JSON]: https://github.com/serde-rs/json\n[Bincode]: https://github.com/servo/bincode\n[CBOR]: https://github.com/enarx/ciborium\n[YAML]: https://github.com/dtolnay/serde-yaml\n[MessagePack]: https://github.com/3Hren/msgpack-rust\n[TOML]: https://github.com/alexcrichton/toml-rs\n[Pickle]: https://github.com/birkenfeld/serde-pickle\n[RON]: https://github.com/ron-rs/ron\n[BSON]: https://github.com/zonyitoo/bson-rs\n[Avro]: https://github.com/flavray/avro-rs\n[JSON5]: https://github.com/callum-oakley/json5-rs\n[Postcard]: https://github.com/jamesmunns/postcard\n[URL]: https://docs.rs/serde_qs\n[Envy]: https://github.com/softprops/envy\n[Envy Store]: https://github.com/softprops/envy-store\n[Cargo]: https://doc.rust-lang.org/cargo/reference/manifest.html\n[AWS Parameter Store]: https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-paramstore.html\n[S-expressions]: https://github.com/rotty/lexpr-rs\n[D-Bus]: https://docs.rs/zvariant\n[FlexBuffers]: https://github.com/google/flatbuffers/tree/master/rust/flexbuffers\n[DynamoDB Items]: https://docs.rs/serde_dynamo\n[rusoto_dynamodb]: https://docs.rs/rusoto_dynamodb"          },          filterText = "serde",          kind = 9,          label = "serde",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2923              },              start = {                character = 6,                line = 2923              }            },            newText = "serde",            replace = {              end = {                character = 13,                line = 2923              },              start = {                character = 6,                line = 2923              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "# Strum\n\nStrum is a set of macros and traits for working with\nenums and strings easier in Rust."          },          filterText = "strum_macros",          kind = 9,          label = "strum_macros",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2923              },              start = {                character = 6,                line = 2923              }            },            newText = "strum_macros",            replace = {              end = {                character = 13,                line = 2923              },              start = {                character = 6,                line = 2923              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "# The Rust Standard Library\n\nThe Rust Standard Library is the foundation of portable Rust software, a\nset of minimal and battle-tested shared abstractions for the [broader Rust\necosystem][crates.io]. It offers core types, like [`Vec<T>`] and\n[`Option<T>`], library-defined [operations on language\nprimitives](#primitives), [standard macros](#macros), [I/O] and\n[multithreading], among [many other things][other].\n\n`std` is available to all Rust crates by default. Therefore, the\nstandard library can be accessed in [`use`] statements through the path\n`std`, as in [`use std::env`].\n\n# How to read this documentation\n\nIf you already know the name of what you are looking for, the fastest way to\nfind it is to use the <a href=\"#\" onclick=\"focusSearchBar();\">search\nbar</a> at the top of the page.\n\nOtherwise, you may want to jump to one of these useful sections:\n\n* [`std::*` modules](#modules)\n* [Primitive types](#primitives)\n* [Standard macros](#macros)\n* [The Rust Prelude]\n\nIf this is your first time, the documentation for the standard library is\nwritten to be casually perused. Clicking on interesting things should\ngenerally lead you to interesting places. Still, there are important bits\nyou don't want to miss, so read on for a tour of the standard library and\nits documentation!\n\nOnce you are familiar with the contents of the standard library you may\nbegin to find the verbosity of the prose distracting. At this stage in your\ndevelopment you may want to press the `[-]` button near the top of the\npage to collapse it into a more skimmable view.\n\nWhile you are looking at that `[-]` button also notice the `source`\nlink. Rust's API documentation comes with the source code and you are\nencouraged to read it. The standard library source is generally high\nquality and a peek behind the curtains is often enlightening.\n\n# What is in the standard library documentation?\n\nFirst of all, The Rust Standard Library is divided into a number of focused\nmodules, [all listed further down this page](#modules). These modules are\nthe bedrock upon which all of Rust is forged, and they have mighty names\nlike [`std::slice`] and [`std::cmp`]. Modules' documentation typically\nincludes an overview of the module along with examples, and are a smart\nplace to start familiarizing yourself with the library.\n\nSecond, implicit methods on [primitive types] are documented here. This can\nbe a source of confusion for two reasons:\n\n1. While primitives are implemented by the compiler, the standard library\n   implements methods directly on the primitive types (and it is the only\n   library that does so), which are [documented in the section on\n   primitives](#primitives).\n2. The standard library exports many modules *with the same name as\n   primitive types*. These define additional items related to the primitive\n   type, but not the all-important methods.\n\nSo for example there is a [page for the primitive type\n`i32`](primitive::i32) that lists all the methods that can be called on\n32-bit integers (very useful), and there is a [page for the module\n`std::i32`] that documents the constant values [`MIN`] and [`MAX`] (rarely\nuseful).\n\nNote the documentation for the primitives [`str`] and [`[T]`][prim@slice] (also\ncalled 'slice'). Many method calls on [`String`] and [`Vec<T>`] are actually\ncalls to methods on [`str`] and [`[T]`][prim@slice] respectively, via [deref\ncoercions][deref-coercions].\n\nThird, the standard library defines [The Rust Prelude], a small collection\nof items - mostly traits - that are imported into every module of every\ncrate. The traits in the prelude are pervasive, making the prelude\ndocumentation a good entry point to learning about the library.\n\nAnd finally, the standard library exports a number of standard macros, and\n[lists them on this page](#macros) (technically, not all of the standard\nmacros are defined by the standard library - some are defined by the\ncompiler - but they are documented here the same). Like the prelude, the\nstandard macros are imported by default into all crates.\n\n# Contributing changes to the documentation\n\nCheck out the rust contribution guidelines [here](\nhttps://rustc-dev-guide.rust-lang.org/contributing.html#writing-documentation).\nThe source for this documentation can be found on\n[GitHub](https://github.com/rust-lang/rust).\nTo contribute changes, make sure you read the guidelines first, then submit\npull-requests for your suggested changes.\n\nContributions are appreciated! If you see a part of the docs that can be\nimproved, submit a PR, or chat with us first on [Discord][rust-discord]\n#docs.\n\n# A Tour of The Rust Standard Library\n\nThe rest of this crate documentation is dedicated to pointing out notable\nfeatures of The Rust Standard Library.\n\n## Containers and collections\n\nThe [`option`] and [`result`] modules define optional and error-handling\ntypes, [`Option<T>`] and [`Result<T, E>`]. The [`iter`] module defines\nRust's iterator trait, [`Iterator`], which works with the [`for`] loop to\naccess collections.\n\nThe standard library exposes three common ways to deal with contiguous\nregions of memory:\n\n* [`Vec<T>`] - A heap-allocated *vector* that is resizable at runtime.\n* [`[T; N]`][prim@array] - An inline *array* with a fixed size at compile time.\n* [`[T]`][prim@slice] - A dynamically sized *slice* into any other kind of contiguous\n  storage, whether heap-allocated or not.\n\nSlices can only be handled through some kind of *pointer*, and as such come\nin many flavors such as:\n\n* `&[T]` - *shared slice*\n* `&mut [T]` - *mutable slice*\n* [`Box<[T]>`][owned slice] - *owned slice*\n\n[`str`], a UTF-8 string slice, is a primitive type, and the standard library\ndefines many methods for it. Rust [`str`]s are typically accessed as\nimmutable references: `&str`. Use the owned [`String`] for building and\nmutating strings.\n\nFor converting to strings use the [`format!`] macro, and for converting from\nstrings use the [`FromStr`] trait.\n\nData may be shared by placing it in a reference-counted box or the [`Rc`]\ntype, and if further contained in a [`Cell`] or [`RefCell`], may be mutated\nas well as shared. Likewise, in a concurrent setting it is common to pair an\natomically-reference-counted box, [`Arc`], with a [`Mutex`] to get the same\neffect.\n\nThe [`collections`] module defines maps, sets, linked lists and other\ntypical collection types, including the common [`HashMap<K, V>`].\n\n## Platform abstractions and I/O\n\nBesides basic data types, the standard library is largely concerned with\nabstracting over differences in common platforms, most notably Windows and\nUnix derivatives.\n\nCommon types of I/O, including [files], [TCP], [UDP], are defined in the\n[`io`], [`fs`], and [`net`] modules.\n\nThe [`thread`] module contains Rust's threading abstractions. [`sync`]\ncontains further primitive shared memory types, including [`atomic`] and\n[`mpsc`], which contains the channel types for message passing.\n\n[I/O]: io\n[`MIN`]: i32::MIN\n[`MAX`]: i32::MAX\n[page for the module `std::i32`]: crate::i32\n[TCP]: net::TcpStream\n[The Rust Prelude]: prelude\n[UDP]: net::UdpSocket\n[`Arc`]: sync::Arc\n[owned slice]: boxed\n[`Cell`]: cell::Cell\n[`FromStr`]: str::FromStr\n[`HashMap<K, V>`]: collections::HashMap\n[`Mutex`]: sync::Mutex\n[`Option<T>`]: option::Option\n[`Rc`]: rc::Rc\n[`RefCell`]: cell::RefCell\n[`Result<T, E>`]: result::Result\n[`Vec<T>`]: vec::Vec\n[`atomic`]: sync::atomic\n[`for`]: ../book/ch03-05-control-flow.html#looping-through-a-collection-with-for\n[`str`]: prim@str\n[`mpsc`]: sync::mpsc\n[`std::cmp`]: cmp\n[`std::slice`]: mod@slice\n[`use std::env`]: env/index.html\n[`use`]: ../book/ch07-02-defining-modules-to-control-scope-and-privacy.html\n[crates.io]: https://crates.io\n[deref-coercions]: ../book/ch15-02-deref.html#implicit-deref-coercions-with-functions-and-methods\n[files]: fs::File\n[multithreading]: thread\n[other]: #what-is-in-the-standard-library-documentation\n[primitive types]: ../book/ch03-02-data-types.html\n[rust-discord]: https://discord.gg/rust-lang\n[array]: prim@array\n[slice]: prim@slice"          },          filterText = "std",          kind = 9,          label = "std",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2923              },              start = {                character = 6,                line = 2923              }            },            newText = "std",            replace = {              end = {                character = 13,                line = 2923              },              start = {                character = 6,                line = 2923              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "[![github]](https://github.com/dtolnay/semver)&ensp;[![crates-io]](https://crates.io/crates/semver)&ensp;[![docs-rs]](https://docs.rs/semver)\n\n[github]: https://img.shields.io/badge/github-8da0cb?style=for-the-badge&labelColor=555555&logo=github\n[crates-io]: https://img.shields.io/badge/crates.io-fc8d62?style=for-the-badge&labelColor=555555&logo=rust\n[docs-rs]: https://img.shields.io/badge/docs.rs-66c2a5?style=for-the-badge&labelColor=555555&logoColor=white&logo=data:image/svg+xml;base64,PHN2ZyByb2xlPSJpbWciIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyIgdmlld0JveD0iMCAwIDUxMiA1MTIiPjxwYXRoIGZpbGw9IiNmNWY1ZjUiIGQ9Ik00ODguNiAyNTAuMkwzOTIgMjE0VjEwNS41YzAtMTUtOS4zLTI4LjQtMjMuNC0zMy43bC0xMDAtMzcuNWMtOC4xLTMuMS0xNy4xLTMuMS0yNS4zIDBsLTEwMCAzNy41Yy0xNC4xIDUuMy0yMy40IDE4LjctMjMuNCAzMy43VjIxNGwtOTYuNiAzNi4yQzkuMyAyNTUuNSAwIDI2OC45IDAgMjgzLjlWMzk0YzAgMTMuNiA3LjcgMjYuMSAxOS45IDMyLjJsMTAwIDUwYzEwLjEgNS4xIDIyLjEgNS4xIDMyLjIgMGwxMDMuOS01MiAxMDMuOSA1MmMxMC4xIDUuMSAyMi4xIDUuMSAzMi4yIDBsMTAwLTUwYzEyLjItNi4xIDE5LjktMTguNiAxOS45LTMyLjJWMjgzLjljMC0xNS05LjMtMjguNC0yMy40LTMzLjd6TTM1OCAyMTQuOGwtODUgMzEuOXYtNjguMmw4NS0zN3Y3My4zek0xNTQgMTA0LjFsMTAyLTM4LjIgMTAyIDM4LjJ2LjZsLTEwMiA0MS40LTEwMi00MS40di0uNnptODQgMjkxLjFsLTg1IDQyLjV2LTc5LjFsODUtMzguOHY3NS40em0wLTExMmwtMTAyIDQxLjQtMTAyLTQxLjR2LS42bDEwMi0zOC4yIDEwMiAzOC4ydi42em0yNDAgMTEybC04NSA0Mi41di03OS4xbDg1LTM4Ljh2NzUuNHptMC0xMTJsLTEwMiA0MS40LTEwMi00MS40di0uNmwxMDItMzguMiAxMDIgMzguMnYuNnoiPjwvcGF0aD48L3N2Zz4K\n\n<br>\n\nA parser and evaluator for Cargo's flavor of Semantic Versioning.\n\nSemantic Versioning (see <https://semver.org>) is a guideline for how\nversion numbers are assigned and incremented. It is widely followed within\nthe Cargo/crates.io ecosystem for Rust.\n\n<br>\n\n# Example\n\n```rust\nuse semver::{BuildMetadata, Prerelease, Version, VersionReq};\n\nfn main() {\n    let req = VersionReq::parse(\">=1.2.3, <1.8.0\").unwrap();\n\n    // Check whether this requirement matches version 1.2.3-alpha.1 (no)\n    let version = Version {\n        major: 1,\n        minor: 2,\n        patch: 3,\n        pre: Prerelease::new(\"alpha.1\").unwrap(),\n        build: BuildMetadata::EMPTY,\n    };\n    assert!(!req.matches(&version));\n\n    // Check whether it matches 1.3.0 (yes it does)\n    let version = Version::parse(\"1.3.0\").unwrap();\n    assert!(req.matches(&version));\n}\n```\n\n<br><br>\n\n# Scope of this crate\n\nBesides Cargo, several other package ecosystems and package managers for\nother languages also use SemVer:&ensp;RubyGems/Bundler for Ruby, npm for\nJavaScript, Composer for PHP, CocoaPods for Objective-C...\n\nThe `semver` crate is specifically intended to implement Cargo's\ninterpretation of Semantic Versioning.\n\nWhere the various tools differ in their interpretation or implementation of\nthe spec, this crate follows the implementation choices made by Cargo. If\nyou are operating on version numbers from some other package ecosystem, you\nwill want to use a different semver library which is appropriate to that\necosystem.\n\nThe extent of Cargo's SemVer support is documented in the *[Specifying\nDependencies]* chapter of the Cargo reference.\n\n[Specifying Dependencies]: https://doc.rust-lang.org/cargo/reference/specifying-dependencies.html"          },          filterText = "semver",          kind = 9,          label = "semver",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2923              },              start = {                character = 6,                line = 2923              }            },            newText = "semver",            replace = {              end = {                character = 13,                line = 2923              },              start = {                character = 6,                line = 2923              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "# reqwest\n\nThe `reqwest` crate provides a convenient, higher-level HTTP\n[`Client`][client].\n\nIt handles many of the things that most people just expect an HTTP client\nto do for them.\n\n- Async and [blocking](blocking) Clients\n- Plain bodies, [JSON](#json), [urlencoded](#forms), [multipart](multipart)\n- Customizable [redirect policy](#redirect-policies)\n- HTTP [Proxies](#proxies)\n- Uses system-native [TLS](#tls)\n- Cookies\n\nThe [`reqwest::Client`][client] is asynchronous. For applications wishing\nto only make a few HTTP requests, the [`reqwest::blocking`](blocking) API\nmay be more convenient.\n\nAdditional learning resources include:\n\n- [The Rust Cookbook](https://rust-lang-nursery.github.io/rust-cookbook/web/clients.html)\n- [Reqwest Repository Examples](https://github.com/seanmonstar/reqwest/tree/master/examples)\n\n## Making a GET request\n\nFor a single request, you can use the [`get`][get] shortcut method.\n\n```rust\nlet body = reqwest::get(\"https://www.rust-lang.org\")\n    .await?\n    .text()\n    .await?;\n\nprintln!(\"body = {:?}\", body);\n```\n\n**NOTE**: If you plan to perform multiple requests, it is best to create a\n[`Client`][client] and reuse it, taking advantage of keep-alive connection\npooling.\n\n## Making POST requests (or setting request bodies)\n\nThere are several ways you can set the body of a request. The basic one is\nby using the `body()` method of a [`RequestBuilder`][builder]. This lets you set the\nexact raw bytes of what the body should be. It accepts various types,\nincluding `String` and `Vec<u8>`. If you wish to pass a custom\ntype, you can use the `reqwest::Body` constructors.\n\n```rust\nlet client = reqwest::Client::new();\nlet res = client.post(\"http://httpbin.org/post\")\n    .body(\"the exact body that is sent\")\n    .send()\n    .await?;\n```\n\n### Forms\n\nIt's very common to want to send form data in a request body. This can be\ndone with any type that can be serialized into form data.\n\nThis can be an array of tuples, or a `HashMap`, or a custom type that\nimplements [`Serialize`][serde].\n\n```rust\n// This will POST a body of `foo=bar&baz=quux`\nlet params = [(\"foo\", \"bar\"), (\"baz\", \"quux\")];\nlet client = reqwest::Client::new();\nlet res = client.post(\"http://httpbin.org/post\")\n    .form(&params)\n    .send()\n    .await?;\n```\n\n### JSON\n\nThere is also a `json` method helper on the [`RequestBuilder`][builder] that works in\na similar fashion the `form` method. It can take any value that can be\nserialized into JSON. The feature `json` is required.\n\n```rust\n// This will POST a body of `{\"lang\":\"rust\",\"body\":\"json\"}`\nlet mut map = HashMap::new();\nmap.insert(\"lang\", \"rust\");\nmap.insert(\"body\", \"json\");\n\nlet client = reqwest::Client::new();\nlet res = client.post(\"http://httpbin.org/post\")\n    .json(&map)\n    .send()\n    .await?;\n```\n\n## Redirect Policies\n\nBy default, a `Client` will automatically handle HTTP redirects, having a\nmaximum redirect chain of 10 hops. To customize this behavior, a\n[`redirect::Policy`][redirect] can be used with a `ClientBuilder`.\n\n## Cookies\n\nThe automatic storing and sending of session cookies can be enabled with\nthe [`cookie_store`][ClientBuilder::cookie_store] method on `ClientBuilder`.\n\n## Proxies\n\n**NOTE**: System proxies are enabled by default.\n\nSystem proxies look in environment variables to set HTTP or HTTPS proxies.\n\n`HTTP_PROXY` or `http_proxy` provide http proxies for http connections while\n`HTTPS_PROXY` or `https_proxy` provide HTTPS proxies for HTTPS connections.\n\nThese can be overwritten by adding a [`Proxy`](Proxy) to `ClientBuilder`\ni.e. `let proxy = reqwest::Proxy::http(\"https://secure.example\")?;`\nor disabled by calling `ClientBuilder::no_proxy()`.\n\n`socks` feature is required if you have configured socks proxy like this:\n\n```bash\nexport https_proxy=socks5://127.0.0.1:1086\n```\n\n## TLS\n\nBy default, a `Client` will make use of system-native transport layer\nsecurity to connect to HTTPS destinations. This means schannel on Windows,\nSecurity-Framework on macOS, and OpenSSL on Linux.\n\n- Additional X509 certificates can be configured on a `ClientBuilder` with the\n  [`Certificate`](Certificate) type.\n- Client certificates can be add to a `ClientBuilder` with the\n  [`Identity`][Identity] type.\n- Various parts of TLS can also be configured or even disabled on the\n  `ClientBuilder`.\n\n## Optional Features\n\nThe following are a list of [Cargo features][cargo-features] that can be\nenabled or disabled:\n\n- **default-tls** *(enabled by default)*: Provides TLS support to connect\n  over HTTPS.\n- **native-tls**: Enables TLS functionality provided by `native-tls`.\n- **native-tls-vendored**: Enables the `vendored` feature of `native-tls`.\n- **native-tls-alpn**: Enables the `alpn` feature of `native-tls`.\n- **rustls-tls**: Enables TLS functionality provided by `rustls`.\n  Equivalent to `rustls-tls-webpki-roots`.\n- **rustls-tls-manual-roots**: Enables TLS functionality provided by `rustls`,\n  without setting any root certificates. Roots have to be specified manually.\n- **rustls-tls-webpki-roots**: Enables TLS functionality provided by `rustls`,\n  while using root certificates from the `webpki-roots` crate.\n- **rustls-tls-native-roots**: Enables TLS functionality provided by `rustls`,\n  while using root certificates from the `rustls-native-certs` crate.\n- **blocking**: Provides the [blocking][] client API.\n- **cookies**: Provides cookie session support.\n- **gzip**: Provides response body gzip decompression.\n- **brotli**: Provides response body brotli decompression.\n- **deflate**: Provides response body deflate decompression.\n- **json**: Provides serialization and deserialization for JSON bodies.\n- **multipart**: Provides functionality for multipart forms.\n- **stream**: Adds support for `futures::Stream`.\n- **socks**: Provides SOCKS5 proxy support.\n- **trust-dns**: Enables a trust-dns async resolver instead of default\n  threadpool using `getaddrinfo`.\n\n\n[hyper]: http://hyper.rs\n[blocking]: ./blocking/index.html\n[client]: ./struct.Client.html\n[response]: ./struct.Response.html\n[get]: ./fn.get.html\n[builder]: ./struct.RequestBuilder.html\n[serde]: http://serde.rs\n[redirect]: crate::redirect\n[Proxy]: ./struct.Proxy.html\n[cargo-features]: https://doc.rust-lang.org/stable/cargo/reference/manifest.html#the-features-section"          },          filterText = "reqwest",          kind = 9,          label = "reqwest",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2923              },              start = {                character = 6,                line = 2923              }            },            newText = "reqwest",            replace = {              end = {                character = 13,                line = 2923              },              start = {                character = 6,                line = 2923              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "# The Rust Core Library\n\nThe Rust Core Library is the dependency-free[^free] foundation of [The\nRust Standard Library](../std/index.html). It is the portable glue\nbetween the language and its libraries, defining the intrinsic and\nprimitive building blocks of all Rust code. It links to no\nupstream libraries, no system libraries, and no libc.\n\n[^free]: Strictly speaking, there are some symbols which are needed but\n         they aren't always necessary.\n\nThe core library is *minimal*: it isn't even aware of heap allocation,\nnor does it provide concurrency or I/O. These things require\nplatform integration, and this library is platform-agnostic.\n\n# How to use the core library\n\nPlease note that all of these details are currently not considered stable.\n\nThis library is built on the assumption of a few existing symbols:\n\n* `memcpy`, `memcmp`, `memset` - These are core memory routines which are\n  often generated by LLVM. Additionally, this library can make explicit\n  calls to these functions. Their signatures are the same as found in C.\n  These functions are often provided by the system libc, but can also be\n  provided by the [compiler-builtins crate](https://crates.io/crates/compiler_builtins).\n\n* `rust_begin_panic` - This function takes four arguments, a\n  `fmt::Arguments`, a `&'static str`, and two `u32`'s. These four arguments\n  dictate the panic message, the file at which panic was invoked, and the\n  line and column inside the file. It is up to consumers of this core\n  library to define this panic function; it is only required to never\n  return. This requires a `lang` attribute named `panic_impl`.\n\n* `rust_eh_personality` - is used by the failure mechanisms of the\n   compiler. This is often mapped to GCC's personality function, but crates\n   which do not trigger a panic can be assured that this function is never\n   called. The `lang` attribute is called `eh_personality`."          },          filterText = "core",          kind = 9,          label = "core",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2923              },              start = {                character = 6,                line = 2923              }            },            newText = "core",            replace = {              end = {                character = 13,                line = 2923              },              start = {                character = 6,                line = 2923              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = '# Strum\n\n[![Build Status](https://travis-ci.org/Peternator7/strum.svg?branch=master)](https://travis-ci.org/Peternator7/strum)\n[![Latest Version](https://img.shields.io/crates/v/strum.svg)](https://crates.io/crates/strum)\n[![Rust Documentation](https://docs.rs/strum/badge.svg)](https://docs.rs/strum)\n\nStrum is a set of macros and traits for working with\nenums and strings easier in Rust.\n\nThe full version of the README can be found on [Github](https://github.com/Peternator7/strum).\n\n# Including Strum in Your Project\n\nImport strum and `strum_macros` into your project by adding the following lines to your\nCargo.toml. `strum_macros` contains the macros needed to derive all the traits in Strum.\n\n```toml\n[dependencies]\nstrum = "0.24"\nstrum_macros = "0.24"\n\n# You can also access strum_macros exports directly through strum using the "derive" feature\nstrum = { version = "0.24", features = ["derive"] }\n```'          },          filterText = "strum",          kind = 9,          label = "strum",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2923              },              start = {                character = 6,                line = 2923              }            },            newText = "strum",            replace = {              end = {                character = 13,                line = 2923              },              start = {                character = 6,                line = 2923              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "# Overview\n\n`once_cell` provides two new cell-like types, [`unsync::OnceCell`] and [`sync::OnceCell`]. A `OnceCell`\nmight store arbitrary non-`Copy` types, can be assigned to at most once and provides direct access\nto the stored contents. The core API looks *roughly* like this (and there's much more inside, read on!):\n\n```rust\nimpl<T> OnceCell<T> {\n    const fn new() -> OnceCell<T> { ... }\n    fn set(&self, value: T) -> Result<(), T> { ... }\n    fn get(&self) -> Option<&T> { ... }\n}\n```\n\nNote that, like with [`RefCell`] and [`Mutex`], the `set` method requires only a shared reference.\nBecause of the single assignment restriction `get` can return a `&T` instead of `Ref<T>`\nor `MutexGuard<T>`.\n\nThe `sync` flavor is thread-safe (that is, implements the [`Sync`] trait), while the `unsync` one is not.\n\n[`unsync::OnceCell`]: unsync/struct.OnceCell.html\n[`sync::OnceCell`]: sync/struct.OnceCell.html\n[`RefCell`]: https://doc.rust-lang.org/std/cell/struct.RefCell.html\n[`Mutex`]: https://doc.rust-lang.org/std/sync/struct.Mutex.html\n[`Sync`]: https://doc.rust-lang.org/std/marker/trait.Sync.html\n\n# Recipes\n\n`OnceCell` might be useful for a variety of patterns.\n\n## Safe Initialization of Global Data\n\n```rust\nuse std::{env, io};\n\nuse once_cell::sync::OnceCell;\n\n#[derive(Debug)]\npub struct Logger {\n    // ...\n}\nstatic INSTANCE: OnceCell<Logger> = OnceCell::new();\n\nimpl Logger {\n    pub fn global() -> &'static Logger {\n        INSTANCE.get().expect(\"logger is not initialized\")\n    }\n\n    fn from_cli(args: env::Args) -> Result<Logger, std::io::Error> {\n       // ...\n    }\n}\n\nfn main() {\n    let logger = Logger::from_cli(env::args()).unwrap();\n    INSTANCE.set(logger).unwrap();\n    // use `Logger::global()` from now on\n}\n```\n\n## Lazy Initialized Global Data\n\nThis is essentially the `lazy_static!` macro, but without a macro.\n\n```rust\nuse std::{sync::Mutex, collections::HashMap};\n\nuse once_cell::sync::OnceCell;\n\nfn global_data() -> &'static Mutex<HashMap<i32, String>> {\n    static INSTANCE: OnceCell<Mutex<HashMap<i32, String>>> = OnceCell::new();\n    INSTANCE.get_or_init(|| {\n        let mut m = HashMap::new();\n        m.insert(13, \"Spica\".to_string());\n        m.insert(74, \"Hoyten\".to_string());\n        Mutex::new(m)\n    })\n}\n```\n\nThere are also the [`sync::Lazy`] and [`unsync::Lazy`] convenience types to streamline this pattern:\n\n```rust\nuse std::{sync::Mutex, collections::HashMap};\nuse once_cell::sync::Lazy;\n\nstatic GLOBAL_DATA: Lazy<Mutex<HashMap<i32, String>>> = Lazy::new(|| {\n    let mut m = HashMap::new();\n    m.insert(13, \"Spica\".to_string());\n    m.insert(74, \"Hoyten\".to_string());\n    Mutex::new(m)\n});\n\nfn main() {\n    println!(\"{:?}\", GLOBAL_DATA.lock().unwrap());\n}\n```\n\nNote that the variable that holds `Lazy` is declared as `static`, *not*\n`const`. This is important: using `const` instead compiles, but works wrong.\n\n[`sync::Lazy`]: sync/struct.Lazy.html\n[`unsync::Lazy`]: unsync/struct.Lazy.html\n\n## General purpose lazy evaluation\n\nUnlike `lazy_static!`, `Lazy` works with local variables.\n\n```rust\nuse once_cell::unsync::Lazy;\n\nfn main() {\n    let ctx = vec![1, 2, 3];\n    let thunk = Lazy::new(|| {\n        ctx.iter().sum::<i32>()\n    });\n    assert_eq!(*thunk, 6);\n}\n```\n\nIf you need a lazy field in a struct, you probably should use `OnceCell`\ndirectly, because that will allow you to access `self` during initialization.\n\n```rust\nuse std::{fs, path::PathBuf};\n\nuse once_cell::unsync::OnceCell;\n\nstruct Ctx {\n    config_path: PathBuf,\n    config: OnceCell<String>,\n}\n\nimpl Ctx {\n    pub fn get_config(&self) -> Result<&str, std::io::Error> {\n        let cfg = self.config.get_or_try_init(|| {\n            fs::read_to_string(&self.config_path)\n        })?;\n        Ok(cfg.as_str())\n    }\n}\n```\n\n## Lazily Compiled Regex\n\nThis is a `regex!` macro which takes a string literal and returns an\n*expression* that evaluates to a `&'static Regex`:\n\n```rust\nmacro_rules! regex {\n    ($re:literal $(,)?) => {{\n        static RE: once_cell::sync::OnceCell<regex::Regex> = once_cell::sync::OnceCell::new();\n        RE.get_or_init(|| regex::Regex::new($re).unwrap())\n    }};\n}\n```\n\nThis macro can be useful to avoid the \"compile regex on every loop iteration\" problem.\n\n## Runtime `include_bytes!`\n\nThe `include_bytes` macro is useful to include test resources, but it slows\ndown test compilation a lot. An alternative is to load the resources at\nruntime:\n\n```rust\nuse std::path::Path;\n\nuse once_cell::sync::OnceCell;\n\npub struct TestResource {\n    path: &'static str,\n    cell: OnceCell<Vec<u8>>,\n}\n\nimpl TestResource {\n    pub const fn new(path: &'static str) -> TestResource {\n        TestResource { path, cell: OnceCell::new() }\n    }\n    pub fn bytes(&self) -> &[u8] {\n        self.cell.get_or_init(|| {\n            let dir = std::env::var(\"CARGO_MANIFEST_DIR\").unwrap();\n            let path = Path::new(dir.as_str()).join(self.path);\n            std::fs::read(&path).unwrap_or_else(|_err| {\n                panic!(\"failed to load test resource: {}\", path.display())\n            })\n        }).as_slice()\n    }\n}\n\nstatic TEST_IMAGE: TestResource = TestResource::new(\"test_data/lena.png\");\n\n#[test]\nfn test_sobel_filter() {\n    let rgb: &[u8] = TEST_IMAGE.bytes();\n    // ...\n}\n```\n\n## `lateinit`\n\n`LateInit` type for delayed initialization. It is reminiscent of Kotlin's\n`lateinit` keyword and allows construction of cyclic data structures:\n\n\n```rust\nuse once_cell::sync::OnceCell;\n\n#[derive(Debug)]\npub struct LateInit<T> { cell: OnceCell<T> }\n\nimpl<T> LateInit<T> {\n    pub fn init(&self, value: T) {\n        assert!(self.cell.set(value).is_ok())\n    }\n}\n\nimpl<T> Default for LateInit<T> {\n    fn default() -> Self { LateInit { cell: OnceCell::default() } }\n}\n\nimpl<T> std::ops::Deref for LateInit<T> {\n    type Target = T;\n    fn deref(&self) -> &T {\n        self.cell.get().unwrap()\n    }\n}\n\n#[derive(Default, Debug)]\nstruct A<'a> {\n    b: LateInit<&'a B<'a>>,\n}\n\n#[derive(Default, Debug)]\nstruct B<'a> {\n    a: LateInit<&'a A<'a>>\n}\n\nfn build_cycle() {\n    let a = A::default();\n    let b = B::default();\n    a.b.init(&b);\n    b.a.init(&a);\n    println!(\"{:?}\", a.b.a.b.a);\n}\n```\n\n# Comparison with std\n\n|`!Sync` types         | Access Mode            | Drawbacks                                     |\n|----------------------|------------------------|-----------------------------------------------|\n|`Cell<T>`             | `T`                    | requires `T: Copy` for `get`                  |\n|`RefCell<T>`          | `RefMut<T>` / `Ref<T>` | may panic at runtime                          |\n|`unsync::OnceCell<T>` | `&T`                   | assignable only once                          |\n\n|`Sync` types          | Access Mode            | Drawbacks                                     |\n|----------------------|------------------------|-----------------------------------------------|\n|`AtomicT`             | `T`                    | works only with certain `Copy` types          |\n|`Mutex<T>`            | `MutexGuard<T>`        | may deadlock at runtime, may block the thread |\n|`sync::OnceCell<T>`   | `&T`                   | assignable only once, may block the thread    |\n\nTechnically, calling `get_or_init` will also cause a panic or a deadlock if it recursively calls\nitself. However, because the assignment can happen only once, such cases should be more rare than\nequivalents with `RefCell` and `Mutex`.\n\n# Minimum Supported `rustc` Version\n\nThis crate's minimum supported `rustc` version is `1.36.0`.\n\nIf only the `std` feature is enabled, MSRV will be updated conservatively.\nWhen using other features, like `parking_lot`, MSRV might be updated more frequently, up to the latest stable.\nIn both cases, increasing MSRV is *not* considered a semver-breaking change.\n\n# Implementation details\n\nThe implementation is based on the [`lazy_static`](https://github.com/rust-lang-nursery/lazy-static.rs/)\nand [`lazy_cell`](https://github.com/indiv0/lazycell/) crates and [`std::sync::Once`]. In some sense,\n`once_cell` just streamlines and unifies those APIs.\n\nTo implement a sync flavor of `OnceCell`, this crates uses either a custom\nre-implementation of `std::sync::Once` or `parking_lot::Mutex`. This is\ncontrolled by the `parking_lot` feature (disabled by default). Performance\nis the same for both cases, but the `parking_lot` based `OnceCell<T>` is\nsmaller by up to 16 bytes.\n\nThis crate uses `unsafe`.\n\n[`std::sync::Once`]: https://doc.rust-lang.org/std/sync/struct.Once.html\n\n# F.A.Q.\n\n**Should I use lazy_static or once_cell?**\n\nTo the first approximation, `once_cell` is both more flexible and more convenient than `lazy_static`\nand should be preferred.\n\nUnlike `once_cell`, `lazy_static` supports spinlock-based implementation of blocking which works with\n`#![no_std]`.\n\n`lazy_static` has received significantly more real world testing, but `once_cell` is also a widely\nused crate.\n\n**Should I use the sync or unsync flavor?**\n\nBecause Rust compiler checks thread safety for you, it's impossible to accidentally use `unsync` where\n`sync` is required. So, use `unsync` in single-threaded code and `sync` in multi-threaded. It's easy\nto switch between the two if code becomes multi-threaded later.\n\nAt the moment, `unsync` has an additional benefit that reentrant initialization causes a panic, which\nmight be easier to debug than a deadlock.\n\n# Related crates\n\n* [double-checked-cell](https://github.com/niklasf/double-checked-cell)\n* [lazy-init](https://crates.io/crates/lazy-init)\n* [lazycell](https://crates.io/crates/lazycell)\n* [mitochondria](https://crates.io/crates/mitochondria)\n* [lazy_static](https://crates.io/crates/lazy_static)\n\nMost of this crate's functionality is available in `std` in nightly Rust.\nSee the [tracking issue](https://github.com/rust-lang/rust/issues/74465)."          },          filterText = "once_cell",          kind = 9,          label = "once_cell",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2923              },              start = {                character = 6,                line = 2923              }            },            newText = "once_cell",            replace = {              end = {                character = 13,                line = 2923              },              start = {                character = 6,                line = 2923              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "[![github]](https://github.com/dtolnay/thiserror)&ensp;[![crates-io]](https://crates.io/crates/thiserror)&ensp;[![docs-rs]](https://docs.rs/thiserror)\n\n[github]: https://img.shields.io/badge/github-8da0cb?style=for-the-badge&labelColor=555555&logo=github\n[crates-io]: https://img.shields.io/badge/crates.io-fc8d62?style=for-the-badge&labelColor=555555&logo=rust\n[docs-rs]: https://img.shields.io/badge/docs.rs-66c2a5?style=for-the-badge&labelColor=555555&logoColor=white&logo=data:image/svg+xml;base64,PHN2ZyByb2xlPSJpbWciIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyIgdmlld0JveD0iMCAwIDUxMiA1MTIiPjxwYXRoIGZpbGw9IiNmNWY1ZjUiIGQ9Ik00ODguNiAyNTAuMkwzOTIgMjE0VjEwNS41YzAtMTUtOS4zLTI4LjQtMjMuNC0zMy43bC0xMDAtMzcuNWMtOC4xLTMuMS0xNy4xLTMuMS0yNS4zIDBsLTEwMCAzNy41Yy0xNC4xIDUuMy0yMy40IDE4LjctMjMuNCAzMy43VjIxNGwtOTYuNiAzNi4yQzkuMyAyNTUuNSAwIDI2OC45IDAgMjgzLjlWMzk0YzAgMTMuNiA3LjcgMjYuMSAxOS45IDMyLjJsMTAwIDUwYzEwLjEgNS4xIDIyLjEgNS4xIDMyLjIgMGwxMDMuOS01MiAxMDMuOSA1MmMxMC4xIDUuMSAyMi4xIDUuMSAzMi4yIDBsMTAwLTUwYzEyLjItNi4xIDE5LjktMTguNiAxOS45LTMyLjJWMjgzLjljMC0xNS05LjMtMjguNC0yMy40LTMzLjd6TTM1OCAyMTQuOGwtODUgMzEuOXYtNjguMmw4NS0zN3Y3My4zek0xNTQgMTA0LjFsMTAyLTM4LjIgMTAyIDM4LjJ2LjZsLTEwMiA0MS40LTEwMi00MS40di0uNnptODQgMjkxLjFsLTg1IDQyLjV2LTc5LjFsODUtMzguOHY3NS40em0wLTExMmwtMTAyIDQxLjQtMTAyLTQxLjR2LS42bDEwMi0zOC4yIDEwMiAzOC4ydi42em0yNDAgMTEybC04NSA0Mi41di03OS4xbDg1LTM4Ljh2NzUuNHptMC0xMTJsLTEwMiA0MS40LTEwMi00MS40di0uNmwxMDItMzguMiAxMDIgMzguMnYuNnoiPjwvcGF0aD48L3N2Zz4K\n\n<br>\n\nThis library provides a convenient derive macro for the standard library's\n[`std::error::Error`] trait.\n\n[`std::error::Error`]: https://doc.rust-lang.org/std/error/trait.Error.html\n\n<br>\n\n# Example\n\n```rust\nuse thiserror::Error;\n\n#[derive(Error, Debug)]\npub enum DataStoreError {\n    #[error(\"data store disconnected\")]\n    Disconnect(#[from] io::Error),\n    #[error(\"the data for key `{0}` is not available\")]\n    Redaction(String),\n    #[error(\"invalid header (expected {expected:?}, found {found:?})\")]\n    InvalidHeader {\n        expected: String,\n        found: String,\n    },\n    #[error(\"unknown data store error\")]\n    Unknown,\n}\n```\n\n<br>\n\n# Details\n\n- Thiserror deliberately does not appear in your public API. You get the\n  same thing as if you had written an implementation of `std::error::Error`\n  by hand, and switching from handwritten impls to thiserror or vice versa\n  is not a breaking change.\n\n- Errors may be enums, structs with named fields, tuple structs, or unit\n  structs.\n\n- A `Display` impl is generated for your error if you provide\n  `#[error(\"...\")]` messages on the struct or each variant of your enum, as\n  shown above in the example.\n\n  The messages support a shorthand for interpolating fields from the error.\n\n    - `#[error(\"{var}\")]`&ensp;⟶&ensp;`write!(\"{}\", self.var)`\n    - `#[error(\"{0}\")]`&ensp;⟶&ensp;`write!(\"{}\", self.0)`\n    - `#[error(\"{var:?}\")]`&ensp;⟶&ensp;`write!(\"{:?}\", self.var)`\n    - `#[error(\"{0:?}\")]`&ensp;⟶&ensp;`write!(\"{:?}\", self.0)`\n\n  These shorthands can be used together with any additional format args,\n  which may be arbitrary expressions. For example:\n\n  ```rust\n  # use std::i32;\n  # use thiserror::Error;\n  #\n  #[derive(Error, Debug)]\n  pub enum Error {\n      #[error(\"invalid rdo_lookahead_frames {0} (expected < {})\", i32::MAX)]\n      InvalidLookahead(u32),\n  }\n  ```\n\n  If one of the additional expression arguments needs to refer to a field of\n  the struct or enum, then refer to named fields as `.var` and tuple fields\n  as `.0`.\n\n  ```rust\n  # use thiserror::Error;\n  #\n  # fn first_char(s: &String) -> char {\n  #     s.chars().next().unwrap()\n  # }\n  #\n  # #[derive(Debug)]\n  # struct Limits {\n  #     lo: usize,\n  #     hi: usize,\n  # }\n  #\n  #[derive(Error, Debug)]\n  pub enum Error {\n      #[error(\"first letter must be lowercase but was {:?}\", first_char(.0))]\n      WrongCase(String),\n      #[error(\"invalid index {idx}, expected at least {} and at most {}\", .limits.lo, .limits.hi)]\n      OutOfBounds { idx: usize, limits: Limits },\n  }\n  ```\n\n- A `From` impl is generated for each variant containing a `#[from]`\n  attribute.\n\n  Note that the variant must not contain any other fields beyond the source\n  error and possibly a backtrace. A backtrace is captured from within the\n  `From` impl if there is a field for it.\n\n  ```rust\n  # const IGNORE: &str = stringify! {\n  #[derive(Error, Debug)]\n  pub enum MyError {\n      Io {\n          #[from]\n          source: io::Error,\n          backtrace: Backtrace,\n      },\n  }\n  # };\n  ```\n\n- The Error trait's `source()` method is implemented to return whichever\n  field has a `#[source]` attribute or is named `source`, if any. This is\n  for identifying the underlying lower level error that caused your error.\n\n  The `#[from]` attribute always implies that the same field is `#[source]`,\n  so you don't ever need to specify both attributes.\n\n  Any error type that implements `std::error::Error` or dereferences to `dyn\n  std::error::Error` will work as a source.\n\n  ```rust\n  # use std::fmt::{self, Display};\n  # use thiserror::Error;\n  #\n  #[derive(Error, Debug)]\n  pub struct MyError {\n      msg: String,\n      #[source]  // optional if field name is `source`\n      source: anyhow::Error,\n  }\n  #\n  # impl Display for MyError {\n  #     fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {\n  #         unimplemented!()\n  #     }\n  # }\n  ```\n\n- The Error trait's `backtrace()` method is implemented to return whichever\n  field has a type named `Backtrace`, if any.\n\n  ```rust\n  # const IGNORE: &str = stringify! {\n  use std::backtrace::Backtrace;\n\n  #[derive(Error, Debug)]\n  pub struct MyError {\n      msg: String,\n      backtrace: Backtrace,  // automatically detected\n  }\n  # };\n  ```\n\n- If a field is both a source (named `source`, or has `#[source]` or\n  `#[from]` attribute) *and* is marked `#[backtrace]`, then the Error\n  trait's `backtrace()` method is forwarded to the source's backtrace.\n\n  ```rust\n  # const IGNORE: &str = stringify! {\n  #[derive(Error, Debug)]\n  pub enum MyError {\n      Io {\n          #[backtrace]\n          source: io::Error,\n      },\n  }\n  # };\n  ```\n\n- Errors may use `error(transparent)` to forward the source and Display\n  methods straight through to an underlying error without adding an\n  additional message. This would be appropriate for enums that need an\n  \"anything else\" variant.\n\n  ```\n  # use thiserror::Error;\n  #\n  #[derive(Error, Debug)]\n  pub enum MyError {\n      # /*\n      ...\n      # */\n\n      #[error(transparent)]\n      Other(#[from] anyhow::Error),  // source and Display delegate to anyhow::Error\n  }\n  ```\n\n- See also the [`anyhow`] library for a convenient single error type to use\n  in application code.\n\n  [`anyhow`]: https://github.com/dtolnay/anyhow"          },          filterText = "thiserror",          kind = 9,          label = "thiserror",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2923              },              start = {                character = 6,                line = 2923              }            },            newText = "thiserror",            replace = {              end = {                character = 13,                line = 2923              },              start = {                character = 6,                line = 2923              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "A runtime for writing reliable network applications without compromising speed.\n\nTokio is an event-driven, non-blocking I/O platform for writing asynchronous\napplications with the Rust programming language. At a high level, it\nprovides a few major components:\n\n* Tools for [working with asynchronous tasks][tasks], including\n  [synchronization primitives and channels][sync] and [timeouts, sleeps, and\n  intervals][time].\n* APIs for [performing asynchronous I/O][io], including [TCP and UDP][net] sockets,\n  [filesystem][fs] operations, and [process] and [signal] management.\n* A [runtime] for executing asynchronous code, including a task scheduler,\n  an I/O driver backed by the operating system's event queue (epoll, kqueue,\n  IOCP, etc...), and a high performance timer.\n\nGuide level documentation is found on the [website].\n\n[tasks]: #working-with-tasks\n[sync]: crate::sync\n[time]: crate::time\n[io]: #asynchronous-io\n[net]: crate::net\n[fs]: crate::fs\n[process]: crate::process\n[signal]: crate::signal\n[fs]: crate::fs\n[runtime]: crate::runtime\n[website]: https://tokio.rs/tokio/tutorial\n\n# A Tour of Tokio\n\nTokio consists of a number of modules that provide a range of functionality\nessential for implementing asynchronous applications in Rust. In this\nsection, we will take a brief tour of Tokio, summarizing the major APIs and\ntheir uses.\n\nThe easiest way to get started is to enable all features. Do this by\nenabling the `full` feature flag:\n\n```toml\ntokio = { version = \"1\", features = [\"full\"] }\n```\n\n### Authoring applications\n\nTokio is great for writing applications and most users in this case shouldn't\nworry too much about what features they should pick. If you're unsure, we suggest\ngoing with `full` to ensure that you don't run into any road blocks while you're\nbuilding your application.\n\n#### Example\n\nThis example shows the quickest way to get started with Tokio.\n\n```toml\ntokio = { version = \"1\", features = [\"full\"] }\n```\n\n### Authoring libraries\n\nAs a library author your goal should be to provide the lightest weight crate\nthat is based on Tokio. To achieve this you should ensure that you only enable\nthe features you need. This allows users to pick up your crate without having\nto enable unnecessary features.\n\n#### Example\n\nThis example shows how you may want to import features for a library that just\nneeds to `tokio::spawn` and use a `TcpStream`.\n\n```toml\ntokio = { version = \"1\", features = [\"rt\", \"net\"] }\n```\n\n## Working With Tasks\n\nAsynchronous programs in Rust are based around lightweight, non-blocking\nunits of execution called [_tasks_][tasks]. The [`tokio::task`] module provides\nimportant tools for working with tasks:\n\n* The [`spawn`] function and [`JoinHandle`] type, for scheduling a new task\n  on the Tokio runtime and awaiting the output of a spawned task, respectively,\n* Functions for [running blocking operations][blocking] in an asynchronous\n  task context.\n\nThe [`tokio::task`] module is present only when the \"rt\" feature flag\nis enabled.\n\n[tasks]: task/index.html#what-are-tasks\n[`tokio::task`]: crate::task\n[`spawn`]: crate::task::spawn()\n[`JoinHandle`]: crate::task::JoinHandle\n[blocking]: task/index.html#blocking-and-yielding\n\nThe [`tokio::sync`] module contains synchronization primitives to use when\nneeding to communicate or share data. These include:\n\n* channels ([`oneshot`], [`mpsc`], and [`watch`]), for sending values\n  between tasks,\n* a non-blocking [`Mutex`], for controlling access to a shared, mutable\n  value,\n* an asynchronous [`Barrier`] type, for multiple tasks to synchronize before\n  beginning a computation.\n\nThe `tokio::sync` module is present only when the \"sync\" feature flag is\nenabled.\n\n[`tokio::sync`]: crate::sync\n[`Mutex`]: crate::sync::Mutex\n[`Barrier`]: crate::sync::Barrier\n[`oneshot`]: crate::sync::oneshot\n[`mpsc`]: crate::sync::mpsc\n[`watch`]: crate::sync::watch\n\nThe [`tokio::time`] module provides utilities for tracking time and\nscheduling work. This includes functions for setting [timeouts][timeout] for\ntasks, [sleeping][sleep] work to run in the future, or [repeating an operation at an\ninterval][interval].\n\nIn order to use `tokio::time`, the \"time\" feature flag must be enabled.\n\n[`tokio::time`]: crate::time\n[sleep]: crate::time::sleep()\n[interval]: crate::time::interval()\n[timeout]: crate::time::timeout()\n\nFinally, Tokio provides a _runtime_ for executing asynchronous tasks. Most\napplications can use the [`#[tokio::main]`][main] macro to run their code on the\nTokio runtime. However, this macro provides only basic configuration options. As\nan alternative, the [`tokio::runtime`] module provides more powerful APIs for configuring\nand managing runtimes. You should use that module if the `#[tokio::main]` macro doesn't\nprovide the functionality you need.\n\nUsing the runtime requires the \"rt\" or \"rt-multi-thread\" feature flags, to\nenable the basic [single-threaded scheduler][rt] and the [thread-pool\nscheduler][rt-multi-thread], respectively. See the [`runtime` module\ndocumentation][rt-features] for details. In addition, the \"macros\" feature\nflag enables the `#[tokio::main]` and `#[tokio::test]` attributes.\n\n[main]: attr.main.html\n[`tokio::runtime`]: crate::runtime\n[`Builder`]: crate::runtime::Builder\n[`Runtime`]: crate::runtime::Runtime\n[rt]: runtime/index.html#current-thread-scheduler\n[rt-multi-thread]: runtime/index.html#multi-thread-scheduler\n[rt-features]: runtime/index.html#runtime-scheduler\n\n## CPU-bound tasks and blocking code\n\nTokio is able to concurrently run many tasks on a few threads by repeatedly\nswapping the currently running task on each thread. However, this kind of\nswapping can only happen at `.await` points, so code that spends a long time\nwithout reaching an `.await` will prevent other tasks from running. To\ncombat this, Tokio provides two kinds of threads: Core threads and blocking\nthreads. The core threads are where all asynchronous code runs, and Tokio\nwill by default spawn one for each CPU core. The blocking threads are\nspawned on demand, can be used to run blocking code that would otherwise\nblock other tasks from running and are kept alive when not used for a certain\namount of time which can be configured with [`thread_keep_alive`].\nSince it is not possible for Tokio to swap out blocking tasks, like it\ncan do with asynchronous code, the upper limit on the number of blocking\nthreads is very large. These limits can be configured on the [`Builder`].\n\nTo spawn a blocking task, you should use the [`spawn_blocking`] function.\n\n[`Builder`]: crate::runtime::Builder\n[`spawn_blocking`]: crate::task::spawn_blocking()\n[`thread_keep_alive`]: crate::runtime::Builder::thread_keep_alive()\n\n```rust\n#[tokio::main]\nasync fn main() {\n    // This is running on a core thread.\n\n    let blocking_task = tokio::task::spawn_blocking(|| {\n        // This is running on a blocking thread.\n        // Blocking here is ok.\n    });\n\n    // We can wait for the blocking task like this:\n    // If the blocking task panics, the unwrap below will propagate the\n    // panic.\n    blocking_task.await.unwrap();\n}\n```\n\nIf your code is CPU-bound and you wish to limit the number of threads used\nto run it, you should use a separate thread pool dedicated to CPU bound tasks.\nFor example, you could consider using the [rayon] library for CPU-bound\ntasks. It is also possible to create an extra Tokio runtime dedicated to\nCPU-bound tasks, but if you do this, you should be careful that the extra\nruntime runs _only_ CPU-bound tasks, as IO-bound tasks on that runtime\nwill behave poorly.\n\nHint: If using rayon, you can use a [`oneshot`] channel to send the result back\nto Tokio when the rayon task finishes.\n\n[rayon]: https://docs.rs/rayon\n[`oneshot`]: crate::sync::oneshot\n\n## Asynchronous IO\n\nAs well as scheduling and running tasks, Tokio provides everything you need\nto perform input and output asynchronously.\n\nThe [`tokio::io`] module provides Tokio's asynchronous core I/O primitives,\nthe [`AsyncRead`], [`AsyncWrite`], and [`AsyncBufRead`] traits. In addition,\nwhen the \"io-util\" feature flag is enabled, it also provides combinators and\nfunctions for working with these traits, forming as an asynchronous\ncounterpart to [`std::io`].\n\nTokio also includes APIs for performing various kinds of I/O and interacting\nwith the operating system asynchronously. These include:\n\n* [`tokio::net`], which contains non-blocking versions of [TCP], [UDP], and\n  [Unix Domain Sockets][UDS] (enabled by the \"net\" feature flag),\n* [`tokio::fs`], similar to [`std::fs`] but for performing filesystem I/O\n  asynchronously (enabled by the \"fs\" feature flag),\n* [`tokio::signal`], for asynchronously handling Unix and Windows OS signals\n  (enabled by the \"signal\" feature flag),\n* [`tokio::process`], for spawning and managing child processes (enabled by\n  the \"process\" feature flag).\n\n[`tokio::io`]: crate::io\n[`AsyncRead`]: crate::io::AsyncRead\n[`AsyncWrite`]: crate::io::AsyncWrite\n[`AsyncBufRead`]: crate::io::AsyncBufRead\n[`std::io`]: std::io\n[`tokio::net`]: crate::net\n[TCP]: crate::net::tcp\n[UDP]: crate::net::UdpSocket\n[UDS]: crate::net::unix\n[`tokio::fs`]: crate::fs\n[`std::fs`]: std::fs\n[`tokio::signal`]: crate::signal\n[`tokio::process`]: crate::process\n\n# Examples\n\nA simple TCP echo server:\n\n```rust\nuse tokio::net::TcpListener;\nuse tokio::io::{AsyncReadExt, AsyncWriteExt};\n\n#[tokio::main]\nasync fn main() -> Result<(), Box<dyn std::error::Error>> {\n    let listener = TcpListener::bind(\"127.0.0.1:8080\").await?;\n\n    loop {\n        let (mut socket, _) = listener.accept().await?;\n\n        tokio::spawn(async move {\n            let mut buf = [0; 1024];\n\n            // In a loop, read data from the socket and write the data back.\n            loop {\n                let n = match socket.read(&mut buf).await {\n                    // socket closed\n                    Ok(n) if n == 0 => return,\n                    Ok(n) => n,\n                    Err(e) => {\n                        eprintln!(\"failed to read from socket; err = {:?}\", e);\n                        return;\n                    }\n                };\n\n                // Write the data back\n                if let Err(e) = socket.write_all(&buf[0..n]).await {\n                    eprintln!(\"failed to write to socket; err = {:?}\", e);\n                    return;\n                }\n            }\n        });\n    }\n}\n```\n\n## Feature flags\n\nTokio uses a set of [feature flags] to reduce the amount of compiled code. It\nis possible to just enable certain features over others. By default, Tokio\ndoes not enable any features but allows one to enable a subset for their use\ncase. Below is a list of the available feature flags. You may also notice\nabove each function, struct and trait there is listed one or more feature flags\nthat are required for that item to be used. If you are new to Tokio it is\nrecommended that you use the `full` feature flag which will enable all public APIs.\nBeware though that this will pull in many extra dependencies that you may not\nneed.\n\n- `full`: Enables all features listed below except `test-util` and `tracing`.\n- `rt`: Enables `tokio::spawn`, the basic (current thread) scheduler,\n        and non-scheduler utilities.\n- `rt-multi-thread`: Enables the heavier, multi-threaded, work-stealing scheduler.\n- `io-util`: Enables the IO based `Ext` traits.\n- `io-std`: Enable `Stdout`, `Stdin` and `Stderr` types.\n- `net`: Enables `tokio::net` types such as `TcpStream`, `UnixStream` and\n         `UdpSocket`, as well as (on Unix-like systems) `AsyncFd` and (on\n         FreeBSD) `PollAio`.\n- `time`: Enables `tokio::time` types and allows the schedulers to enable\n          the built in timer.\n- `process`: Enables `tokio::process` types.\n- `macros`: Enables `#[tokio::main]` and `#[tokio::test]` macros.\n- `sync`: Enables all `tokio::sync` types.\n- `signal`: Enables all `tokio::signal` types.\n- `fs`: Enables `tokio::fs` types.\n- `test-util`: Enables testing based infrastructure for the Tokio runtime.\n\n_Note: `AsyncRead` and `AsyncWrite` traits do not require any features and are\nalways available._\n\n### Internal features\n\nThese features do not expose any new API, but influence internal\nimplementation aspects of Tokio, and can pull in additional\ndependencies.\n\n- `parking_lot`: As a potential optimization, use the _parking_lot_ crate's\nsynchronization primitives internally. MSRV may increase according to the\n_parking_lot_ release in use.\n\n### Unstable features\n\nThese feature flags enable **unstable** features. The public API may break in 1.x\nreleases. To enable these features, the `--cfg tokio_unstable` must be passed to\n`rustc` when compiling. This is easiest done using the `RUSTFLAGS` env variable:\n`RUSTFLAGS=\"--cfg tokio_unstable\"`.\n\n- `tracing`: Enables tracing events.\n\n[feature flags]: https://doc.rust-lang.org/cargo/reference/manifest.html#the-features-section"          },          filterText = "tokio",          kind = 9,          label = "tokio",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2923              },              start = {                character = 6,                line = 2923              }            },            newText = "tokio",            replace = {              end = {                character = 13,                line = 2923              },              start = {                character = 6,                line = 2923              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "This is a library to compare and sort strings (or file paths) **lexicographically**. This\nmeans that non-ASCII characters such as `á` or `ß` are treated like their closest ASCII\ncharacter: `á` is treated as `a`, `ß` is treated as `ss`, etc.\n\nLexical comparisons are case-insensitive. Alphanumeric characters are sorted after all other\ncharacters (punctuation, whitespace, special characters, emojis, ...).\n\nIt is possible to enable **natural sorting**, which also handles ASCII numbers. For example,\n`50` is less than `100` with natural sorting turned on. It's also possible to skip\ncharacters that aren't alphanumeric, so e.g. `f-5` is next to `f5`.\n\nIf different strings have the same ASCII representation (e.g. `\"Foo\"` and `\"fóò\"`), it\nfalls back to the default method from the standard library, so sorting is deterministic.\n\n<table><tr><td>\n<b>NOTE</b>: This crate doesn't attempt to be correct for every locale, but it should work\nreasonably well for a wide range of locales, while providing excellent performance.\n</td></tr></table>\n\n## Usage\n\nTo sort strings or paths, you can use the `StringSort` or `PathSort` trait:\n\n```rust\nuse lexical_sort::{StringSort, natural_lexical_cmp};\n\nlet mut strings = vec![\"ß\", \"é\", \"100\", \"hello\", \"world\", \"50\", \".\", \"B!\"];\nstrings.string_sort_unstable(natural_lexical_cmp);\n\nassert_eq!(&strings, &[\".\", \"50\", \"100\", \"B!\", \"é\", \"hello\", \"ß\", \"world\"]);\n```\n\nThere are eight comparison functions:\n\n| Function                         | lexico­graphical | natural | skips non-alphanumeric chars |\n| -------------------------------- |:---------------:|:-------:|:----------------------------:|\n| `cmp`                            |                 |         |                              |\n| `only_alnum_cmp`                 |                 |         | yes                          |\n| `lexical_cmp`                    | yes             |         |                              |\n| `lexical_only_alnum_cmp`         | yes             |         | yes                          |\n| `natural_cmp`                    |                 | yes     |                              |\n| `natural_only_alnum_cmp`         |                 | yes     | yes                          |\n| `natural_lexical_cmp`            | yes             | yes     |                              |\n| `natural_lexical_­only_alnum_cmp` | yes             | yes     | yes                          |\n\nNote that only the functions that sort lexicographically are case insensitive."          },          filterText = "lexical_sort",          kind = 9,          label = "lexical_sort",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2923              },              start = {                character = 6,                line = 2923              }            },            newText = "lexical_sort",            replace = {              end = {                character = 13,                line = 2923              },              start = {                character = 6,                line = 2923              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro cfg_accessible",          documentation = {            kind = "markdown",            value = "Keeps the item it's applied to if the passed path is accessible, and removes it otherwise."          },          filterText = "cfg_accessible",          kind = 3,          label = "cfg_accessible",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2923              },              start = {                character = 6,                line = 2923              }            },            newText = "cfg_accessible",            replace = {              end = {                character = 13,                line = 2923              },              start = {                character = 6,                line = 2923              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro test_case",          documentation = {            kind = "markdown",            value = "An implementation detail of the `#[test]` and `#[bench]` macros."          },          filterText = "test_case",          kind = 3,          label = "test_case",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2923              },              start = {                character = 6,                line = 2923              }            },            newText = "test_case",            replace = {              end = {                character = 13,                line = 2923              },              start = {                character = 6,                line = 2923              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro derive",          documentation = {            kind = "markdown",            value = "Attribute macro used to apply derive macros.\n\nSee [the reference] for more info.\n\n[the reference]: ../../../reference/attributes/derive.html"          },          filterText = "derive",          kind = 3,          label = "derive",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2923              },              start = {                character = 6,                line = 2923              }            },            newText = "derive",            replace = {              end = {                character = 13,                line = 2923              },              start = {                character = 6,                line = 2923              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro test",          documentation = {            kind = "markdown",            value = "Attribute macro applied to a function to turn it into a unit test.\n\nSee [the reference] for more info.\n\n[the reference]: ../../../reference/attributes/testing.html#the-test-attribute"          },          filterText = "test",          kind = 3,          label = "test",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2923              },              start = {                character = 6,                line = 2923              }            },            newText = "test",            replace = {              end = {                character = 13,                line = 2923              },              start = {                character = 6,                line = 2923              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro bench",          documentation = {            kind = "markdown",            value = "Attribute macro applied to a function to turn it into a benchmark test."          },          filterText = "bench",          kind = 3,          label = "bench",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2923              },              start = {                character = 6,                line = 2923              }            },            newText = "bench",            replace = {              end = {                character = 13,                line = 2923              },              start = {                character = 6,                line = 2923              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro global_allocator",          documentation = {            kind = "markdown",            value = "Attribute macro applied to a static to register it as a global allocator.\n\nSee also [`std::alloc::GlobalAlloc`](../../../std/alloc/trait.GlobalAlloc.html)."          },          filterText = "global_allocator",          kind = 3,          label = "global_allocator",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2923              },              start = {                character = 6,                line = 2923              }            },            newText = "global_allocator",            replace = {              end = {                character = 13,                line = 2923              },              start = {                character = 6,                line = 2923              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro cfg_eval",          documentation = {            kind = "markdown",            value = "Expands all `#[cfg]` and `#[cfg_attr]` attributes in the code fragment it's applied to."          },          filterText = "cfg_eval",          kind = 3,          label = "cfg_eval",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2923              },              start = {                character = 6,                line = 2923              }            },            newText = "cfg_eval",            replace = {              end = {                character = 13,                line = 2923              },              start = {                character = 6,                line = 2923              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "self::",          kind = 14,          label = "self::",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2923              },              start = {                character = 6,                line = 2923              }            },            newText = "self::",            replace = {              end = {                character = 13,                line = 2923              },              start = {                character = 6,                line = 2923              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "super::",          kind = 14,          label = "super::",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2923              },              start = {                character = 6,                line = 2923              }            },            newText = "super::",            replace = {              end = {                character = 13,                line = 2923              },              start = {                character = 6,                line = 2923              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "crate::",          kind = 14,          label = "crate::",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2923              },              start = {                character = 6,                line = 2923              }            },            newText = "crate::",            replace = {              end = {                character = 13,                line = 2923              },              start = {                character = 6,                line = 2923              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "allow",          insertTextFormat = 2,          kind = 3,          label = "allow(…)",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2923              },              start = {                character = 6,                line = 2923              }            },            newText = "allow(${0:lint})",            replace = {              end = {                character = 13,                line = 2923              },              start = {                character = 6,                line = 2923              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "cfg",          insertTextFormat = 2,          kind = 3,          label = "cfg(…)",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2923              },              start = {                character = 6,                line = 2923              }            },            newText = "cfg(${0:predicate})",            replace = {              end = {                character = 13,                line = 2923              },              start = {                character = 6,                line = 2923              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "cfg_attr",          insertTextFormat = 2,          kind = 3,          label = "cfg_attr(…)",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2923              },              start = {                character = 6,                line = 2923              }            },            newText = "cfg_attr(${1:predicate}, ${0:attr})",            replace = {              end = {                character = 13,                line = 2923              },              start = {                character = 6,                line = 2923              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "deny",          insertTextFormat = 2,          kind = 3,          label = "deny(…)",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2923              },              start = {                character = 6,                line = 2923              }            },            newText = "deny(${0:lint})",            replace = {              end = {                character = 13,                line = 2923              },              start = {                character = 6,                line = 2923              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "forbid",          insertTextFormat = 2,          kind = 3,          label = "forbid(…)",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2923              },              start = {                character = 6,                line = 2923              }            },            newText = "forbid(${0:lint})",            replace = {              end = {                character = 13,                line = 2923              },              start = {                character = 6,                line = 2923              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "warn",          insertTextFormat = 2,          kind = 3,          label = "warn(…)",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2923              },              start = {                character = 6,                line = 2923              }            },            newText = "warn(${0:lint})",            replace = {              end = {                character = 13,                line = 2923              },              start = {                character = 6,                line = 2923              }            }          }        }, {          additionalTextEdits = {},          data = {            imports = { {                full_import_path = "std::default",                imported_name = "default"              } },            position = {              position = {                character = 7,                line = 2923              },              textDocument = {                uri = "file:///home/jtcf/rustworks/factorio-lib-rs/src/prototypes/mod.rs"              }            }          },          deprecated = false,          documentation = {            kind = "markdown",            value = "The `Default` trait for types which may have meaningful default values."          },          filterText = "default",          kind = 9,          label = "default (use std::default)",          sortText = "fffffff0",          textEdit = {            insert = {              end = {                character = 7,                line = 2923              },              start = {                character = 6,                line = 2923              }            },            newText = "default",            replace = {              end = {                character = 13,                line = 2923              },              start = {                character = 6,                line = 2923              }            }          }        } }    }  }}
[ERROR][2022-06-08 11:21:48] .../vim/lsp/rpc.lua:534	"No callback found for server response id 11"
[ERROR][2022-06-08 11:21:48] .../lua/vim/lsp.lua:824	"LSP[rust_analyzer]"	"on_error"	{  code = "NO_RESULT_CALLBACK_FOUND",  err = {    id = 11,    jsonrpc = "2.0",    result = {      isIncomplete = true,      items = { {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "Utilities for formatting and printing `String`s.\n\nThis module contains the runtime support for the [`format!`] syntax extension.\nThis macro is implemented in the compiler to emit calls to this module in\norder to format arguments at runtime into strings.\n\n# Usage\n\nThe [`format!`] macro is intended to be familiar to those coming from C's\n`printf`/`fprintf` functions or Python's `str.format` function.\n\nSome examples of the [`format!`] extension are:\n\n```rust\nformat!(\"Hello\");                 // => \"Hello\"\nformat!(\"Hello, {}!\", \"world\");   // => \"Hello, world!\"\nformat!(\"The number is {}\", 1);   // => \"The number is 1\"\nformat!(\"{:?}\", (3, 4));          // => \"(3, 4)\"\nformat!(\"{value}\", value=4);      // => \"4\"\nlet people = \"Rustaceans\";\nformat!(\"Hello {people}!\");       // => \"Hello Rustaceans!\"\nformat!(\"{} {}\", 1, 2);           // => \"1 2\"\nformat!(\"{:04}\", 42);             // => \"0042\" with leading zeros\nformat!(\"{:#?}\", (100, 200));     // => \"(\n                                  //       100,\n                                  //       200,\n                                  //     )\"\n```\n\nFrom these, you can see that the first argument is a format string. It is\nrequired by the compiler for this to be a string literal; it cannot be a\nvariable passed in (in order to perform validity checking). The compiler\nwill then parse the format string and determine if the list of arguments\nprovided is suitable to pass to this format string.\n\nTo convert a single value to a string, use the [`to_string`] method. This\nwill use the [`Display`] formatting trait.\n\n## Positional parameters\n\nEach formatting argument is allowed to specify which value argument it's\nreferencing, and if omitted it is assumed to be \"the next argument\". For\nexample, the format string `{} {} {}` would take three parameters, and they\nwould be formatted in the same order as they're given. The format string\n`{2} {1} {0}`, however, would format arguments in reverse order.\n\nThings can get a little tricky once you start intermingling the two types of\npositional specifiers. The \"next argument\" specifier can be thought of as an\niterator over the argument. Each time a \"next argument\" specifier is seen,\nthe iterator advances. This leads to behavior like this:\n\n```rust\nformat!(\"{1} {} {0} {}\", 1, 2); // => \"2 1 1 2\"\n```\n\nThe internal iterator over the argument has not been advanced by the time\nthe first `{}` is seen, so it prints the first argument. Then upon reaching\nthe second `{}`, the iterator has advanced forward to the second argument.\nEssentially, parameters that explicitly name their argument do not affect\nparameters that do not name an argument in terms of positional specifiers.\n\nA format string is required to use all of its arguments, otherwise it is a\ncompile-time error. You may refer to the same argument more than once in the\nformat string.\n\n## Named parameters\n\nRust itself does not have a Python-like equivalent of named parameters to a\nfunction, but the [`format!`] macro is a syntax extension that allows it to\nleverage named parameters. Named parameters are listed at the end of the\nargument list and have the syntax:\n\n```text\nidentifier '=' expression\n```\n\nFor example, the following [`format!`] expressions all use named arguments:\n\n```rust\nformat!(\"{argument}\", argument = \"test\");   // => \"test\"\nformat!(\"{name} {}\", 1, name = 2);          // => \"2 1\"\nformat!(\"{a} {c} {b}\", a=\"a\", b='b', c=3);  // => \"a 3 b\"\n```\n\nIf a named parameter does not appear in the argument list, `format!` will\nreference a variable with that name in the current scope.\n\n```rust\nlet argument = 2 + 2;\nformat!(\"{argument}\");   // => \"4\"\n\nfn make_string(a: u32, b: &str) -> String {\n    format!(\"{b} {a}\")\n}\nmake_string(927, \"label\"); // => \"label 927\"\n```\n\nIt is not valid to put positional parameters (those without names) after\narguments that have names. Like with positional parameters, it is not\nvalid to provide named parameters that are unused by the format string.\n\n# Formatting Parameters\n\nEach argument being formatted can be transformed by a number of formatting\nparameters (corresponding to `format_spec` in [the syntax](#syntax)). These\nparameters affect the string representation of what's being formatted.\n\n## Width\n\n```rust\n// All of these print \"Hello x    !\"\nprintln!(\"Hello {:5}!\", \"x\");\nprintln!(\"Hello {:1$}!\", \"x\", 5);\nprintln!(\"Hello {1:0$}!\", 5, \"x\");\nprintln!(\"Hello {:width$}!\", \"x\", width = 5);\nlet width = 5;\nprintln!(\"Hello {:width$}!\", \"x\");\n```\n\nThis is a parameter for the \"minimum width\" that the format should take up.\nIf the value's string does not fill up this many characters, then the\npadding specified by fill/alignment will be used to take up the required\nspace (see below).\n\nThe value for the width can also be provided as a [`usize`] in the list of\nparameters by adding a postfix `$`, indicating that the second argument is\na [`usize`] specifying the width.\n\nReferring to an argument with the dollar syntax does not affect the \"next\nargument\" counter, so it's usually a good idea to refer to arguments by\nposition, or use named arguments.\n\n## Fill/Alignment\n\n```rust\nassert_eq!(format!(\"Hello {:<5}!\", \"x\"),  \"Hello x    !\");\nassert_eq!(format!(\"Hello {:-<5}!\", \"x\"), \"Hello x----!\");\nassert_eq!(format!(\"Hello {:^5}!\", \"x\"),  \"Hello   x  !\");\nassert_eq!(format!(\"Hello {:>5}!\", \"x\"),  \"Hello     x!\");\n```\n\nThe optional fill character and alignment is provided normally in conjunction with the\n[`width`](#width) parameter. It must be defined before `width`, right after the `:`.\nThis indicates that if the value being formatted is smaller than\n`width` some extra characters will be printed around it.\nFilling comes in the following variants for different alignments:\n\n* `[fill]<` - the argument is left-aligned in `width` columns\n* `[fill]^` - the argument is center-aligned in `width` columns\n* `[fill]>` - the argument is right-aligned in `width` columns\n\nThe default [fill/alignment](#fillalignment) for non-numerics is a space and\nleft-aligned. The\ndefault for numeric formatters is also a space character but with right-alignment. If\nthe `0` flag (see below) is specified for numerics, then the implicit fill character is\n`0`.\n\nNote that alignment might not be implemented by some types. In particular, it\nis not generally implemented for the `Debug` trait.  A good way to ensure\npadding is applied is to format your input, then pad this resulting string\nto obtain your output:\n\n```rust\nprintln!(\"Hello {:^15}!\", format!(\"{:?}\", Some(\"hi\"))); // => \"Hello   Some(\"hi\")   !\"\n```\n\n## Sign/`#`/`0`\n\n```rust\nassert_eq!(format!(\"Hello {:+}!\", 5), \"Hello +5!\");\nassert_eq!(format!(\"{:#x}!\", 27), \"0x1b!\");\nassert_eq!(format!(\"Hello {:05}!\", 5),  \"Hello 00005!\");\nassert_eq!(format!(\"Hello {:05}!\", -5), \"Hello -0005!\");\nassert_eq!(format!(\"{:#010x}!\", 27), \"0x0000001b!\");\n```\n\nThese are all flags altering the behavior of the formatter.\n\n* `+` - This is intended for numeric types and indicates that the sign\n        should always be printed. Positive signs are never printed by\n        default, and the negative sign is only printed by default for signed values.\n        This flag indicates that the correct sign (`+` or `-`) should always be printed.\n* `-` - Currently not used\n* `#` - This flag indicates that the \"alternate\" form of printing should\n        be used. The alternate forms are:\n    * `#?` - pretty-print the [`Debug`] formatting (adds linebreaks and indentation)\n    * `#x` - precedes the argument with a `0x`\n    * `#X` - precedes the argument with a `0x`\n    * `#b` - precedes the argument with a `0b`\n    * `#o` - precedes the argument with a `0o`\n* `0` - This is used to indicate for integer formats that the padding to `width` should\n        both be done with a `0` character as well as be sign-aware. A format\n        like `{:08}` would yield `00000001` for the integer `1`, while the\n        same format would yield `-0000001` for the integer `-1`. Notice that\n        the negative version has one fewer zero than the positive version.\n        Note that padding zeros are always placed after the sign (if any)\n        and before the digits. When used together with the `#` flag, a similar\n        rule applies: padding zeros are inserted after the prefix but before\n        the digits. The prefix is included in the total width.\n\n## Precision\n\nFor non-numeric types, this can be considered a \"maximum width\". If the resulting string is\nlonger than this width, then it is truncated down to this many characters and that truncated\nvalue is emitted with proper `fill`, `alignment` and `width` if those parameters are set.\n\nFor integral types, this is ignored.\n\nFor floating-point types, this indicates how many digits after the decimal point should be\nprinted.\n\nThere are three possible ways to specify the desired `precision`:\n\n1. An integer `.N`:\n\n   the integer `N` itself is the precision.\n\n2. An integer or name followed by dollar sign `.N$`:\n\n   use format *argument* `N` (which must be a `usize`) as the precision.\n\n3. An asterisk `.*`:\n\n   `.*` means that this `{...}` is associated with *two* format inputs rather than one: the\n   first input holds the `usize` precision, and the second holds the value to print. Note that\n   in this case, if one uses the format string `{<arg>:<spec>.*}`, then the `<arg>` part refers\n   to the *value* to print, and the `precision` must come in the input preceding `<arg>`.\n\nFor example, the following calls all print the same thing `Hello x is 0.01000`:\n\n```rust\n// Hello {arg 0 (\"x\")} is {arg 1 (0.01) with precision specified inline (5)}\nprintln!(\"Hello {0} is {1:.5}\", \"x\", 0.01);\n\n// Hello {arg 1 (\"x\")} is {arg 2 (0.01) with precision specified in arg 0 (5)}\nprintln!(\"Hello {1} is {2:.0$}\", 5, \"x\", 0.01);\n\n// Hello {arg 0 (\"x\")} is {arg 2 (0.01) with precision specified in arg 1 (5)}\nprintln!(\"Hello {0} is {2:.1$}\", \"x\", 5, 0.01);\n\n// Hello {next arg (\"x\")} is {second of next two args (0.01) with precision\n//                          specified in first of next two args (5)}\nprintln!(\"Hello {} is {:.*}\",    \"x\", 5, 0.01);\n\n// Hello {next arg (\"x\")} is {arg 2 (0.01) with precision\n//                          specified in its predecessor (5)}\nprintln!(\"Hello {} is {2:.*}\",   \"x\", 5, 0.01);\n\n// Hello {next arg (\"x\")} is {arg \"number\" (0.01) with precision specified\n//                          in arg \"prec\" (5)}\nprintln!(\"Hello {} is {number:.prec$}\", \"x\", prec = 5, number = 0.01);\n```\n\nWhile these:\n\n```rust\nprintln!(\"{}, `{name:.*}` has 3 fractional digits\", \"Hello\", 3, name=1234.56);\nprintln!(\"{}, `{name:.*}` has 3 characters\", \"Hello\", 3, name=\"1234.56\");\nprintln!(\"{}, `{name:>8.*}` has 3 right-aligned characters\", \"Hello\", 3, name=\"1234.56\");\n```\n\nprint three significantly different things:\n\n```text\nHello, `1234.560` has 3 fractional digits\nHello, `123` has 3 characters\nHello, `     123` has 3 right-aligned characters\n```\n\n## Localization\n\nIn some programming languages, the behavior of string formatting functions\ndepends on the operating system's locale setting. The format functions\nprovided by Rust's standard library do not have any concept of locale and\nwill produce the same results on all systems regardless of user\nconfiguration.\n\nFor example, the following code will always print `1.5` even if the system\nlocale uses a decimal separator other than a dot.\n\n```rust\nprintln!(\"The value is {}\", 1.5);\n```\n\n# Escaping\n\nThe literal characters `{` and `}` may be included in a string by preceding\nthem with the same character. For example, the `{` character is escaped with\n`{{` and the `}` character is escaped with `}}`.\n\n```rust\nassert_eq!(format!(\"Hello {{}}\"), \"Hello {}\");\nassert_eq!(format!(\"{{ Hello\"), \"{ Hello\");\n```\n\n# Syntax\n\nTo summarize, here you can find the full grammar of format strings.\nThe syntax for the formatting language used is drawn from other languages,\nso it should not be too alien. Arguments are formatted with Python-like\nsyntax, meaning that arguments are surrounded by `{}` instead of the C-like\n`%`. The actual grammar for the formatting syntax is:\n\n```text\nformat_string := text [ maybe_format text ] *\nmaybe_format := '{' '{' | '}' '}' | format\nformat := '{' [ argument ] [ ':' format_spec ] '}'\nargument := integer | identifier\n\nformat_spec := [[fill]align][sign]['#']['0'][width]['.' precision]type\nfill := character\nalign := '<' | '^' | '>'\nsign := '+' | '-'\nwidth := count\nprecision := count | '*'\ntype := '' | '?' | 'x?' | 'X?' | identifier\ncount := parameter | integer\nparameter := argument '$'\n```\nIn the above grammar, `text` must not contain any `'{'` or `'}'` characters.\n\n# Formatting traits\n\nWhen requesting that an argument be formatted with a particular type, you\nare actually requesting that an argument ascribes to a particular trait.\nThis allows multiple actual types to be formatted via `{:x}` (like [`i8`] as\nwell as [`isize`]). The current mapping of types to traits is:\n\n* *nothing* ⇒ [`Display`]\n* `?` ⇒ [`Debug`]\n* `x?` ⇒ [`Debug`] with lower-case hexadecimal integers\n* `X?` ⇒ [`Debug`] with upper-case hexadecimal integers\n* `o` ⇒ [`Octal`]\n* `x` ⇒ [`LowerHex`]\n* `X` ⇒ [`UpperHex`]\n* `p` ⇒ [`Pointer`]\n* `b` ⇒ [`Binary`]\n* `e` ⇒ [`LowerExp`]\n* `E` ⇒ [`UpperExp`]\n\nWhat this means is that any type of argument which implements the\n[`fmt::Binary`][`Binary`] trait can then be formatted with `{:b}`. Implementations\nare provided for these traits for a number of primitive types by the\nstandard library as well. If no format is specified (as in `{}` or `{:6}`),\nthen the format trait used is the [`Display`] trait.\n\nWhen implementing a format trait for your own type, you will have to\nimplement a method of the signature:\n\n```rust\nfn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n```\n\nYour type will be passed as `self` by-reference, and then the function\nshould emit output into the `f.buf` stream. It is up to each format trait\nimplementation to correctly adhere to the requested formatting parameters.\nThe values of these parameters will be listed in the fields of the\n[`Formatter`] struct. In order to help with this, the [`Formatter`] struct also\nprovides some helper methods.\n\nAdditionally, the return value of this function is [`fmt::Result`] which is a\ntype alias of <code>[Result]<(), [std::fmt::Error]></code>. Formatting implementations\nshould ensure that they propagate errors from the [`Formatter`] (e.g., when\ncalling [`write!`]). However, they should never return errors spuriously. That\nis, a formatting implementation must and may only return an error if the\npassed-in [`Formatter`] returns an error. This is because, contrary to what\nthe function signature might suggest, string formatting is an infallible\noperation. This function only returns a result because writing to the\nunderlying stream might fail and it must provide a way to propagate the fact\nthat an error has occurred back up the stack.\n\nAn example of implementing the formatting traits would look\nlike:\n\n```rust\nuse std::fmt;\n\n#[derive(Debug)]\nstruct Vector2D {\n    x: isize,\n    y: isize,\n}\n\nimpl fmt::Display for Vector2D {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        // The `f` value implements the `Write` trait, which is what the\n        // write! macro is expecting. Note that this formatting ignores the\n        // various flags provided to format strings.\n        write!(f, \"({}, {})\", self.x, self.y)\n    }\n}\n\n// Different traits allow different forms of output of a type. The meaning\n// of this format is to print the magnitude of a vector.\nimpl fmt::Binary for Vector2D {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        let magnitude = (self.x * self.x + self.y * self.y) as f64;\n        let magnitude = magnitude.sqrt();\n\n        // Respect the formatting flags by using the helper method\n        // `pad_integral` on the Formatter object. See the method\n        // documentation for details, and the function `pad` can be used\n        // to pad strings.\n        let decimals = f.precision().unwrap_or(3);\n        let string = format!(\"{:.*}\", decimals, magnitude);\n        f.pad_integral(true, \"\", &string)\n    }\n}\n\nfn main() {\n    let myvector = Vector2D { x: 3, y: 4 };\n\n    println!(\"{myvector}\");       // => \"(3, 4)\"\n    println!(\"{myvector:?}\");     // => \"Vector2D {x: 3, y:4}\"\n    println!(\"{myvector:10.3b}\"); // => \"     5.000\"\n}\n```\n\n### `fmt::Display` vs `fmt::Debug`\n\nThese two formatting traits have distinct purposes:\n\n- [`fmt::Display`][`Display`] implementations assert that the type can be faithfully\n  represented as a UTF-8 string at all times. It is **not** expected that\n  all types implement the [`Display`] trait.\n- [`fmt::Debug`][`Debug`] implementations should be implemented for **all** public types.\n  Output will typically represent the internal state as faithfully as possible.\n  The purpose of the [`Debug`] trait is to facilitate debugging Rust code. In\n  most cases, using `#[derive(Debug)]` is sufficient and recommended.\n\nSome examples of the output from both traits:\n\n```rust\nassert_eq!(format!(\"{} {:?}\", 3, 4), \"3 4\");\nassert_eq!(format!(\"{} {:?}\", 'a', 'b'), \"a 'b'\");\nassert_eq!(format!(\"{} {:?}\", \"foo\\n\", \"bar\\n\"), \"foo\\n \\\"bar\\\\n\\\"\");\n```\n\n# Related macros\n\nThere are a number of related macros in the [`format!`] family. The ones that\nare currently implemented are:\n\n```rust\nformat!      // described above\nwrite!       // first argument is a &mut io::Write, the destination\nwriteln!     // same as write but appends a newline\nprint!       // the format string is printed to the standard output\nprintln!     // same as print but appends a newline\neprint!      // the format string is printed to the standard error\neprintln!    // same as eprint but appends a newline\nformat_args! // described below.\n```\n\n### `write!`\n\nThis and [`writeln!`] are two macros which are used to emit the format string\nto a specified stream. This is used to prevent intermediate allocations of\nformat strings and instead directly write the output. Under the hood, this\nfunction is actually invoking the [`write_fmt`] function defined on the\n[`std::io::Write`] trait. Example usage is:\n\n```rust\nuse std::io::Write;\nlet mut w = Vec::new();\nwrite!(&mut w, \"Hello {}!\", \"world\");\n```\n\n### `print!`\n\nThis and [`println!`] emit their output to stdout. Similarly to the [`write!`]\nmacro, the goal of these macros is to avoid intermediate allocations when\nprinting output. Example usage is:\n\n```rust\nprint!(\"Hello {}!\", \"world\");\nprintln!(\"I have a newline {}\", \"character at the end\");\n```\n### `eprint!`\n\nThe [`eprint!`] and [`eprintln!`] macros are identical to\n[`print!`] and [`println!`], respectively, except they emit their\noutput to stderr.\n\n### `format_args!`\n\nThis is a curious macro used to safely pass around\nan opaque object describing the format string. This object\ndoes not require any heap allocations to create, and it only\nreferences information on the stack. Under the hood, all of\nthe related macros are implemented in terms of this. First\noff, some example usage is:\n\n```rust\nuse std::fmt;\nuse std::io::{self, Write};\n\nlet mut some_writer = io::stdout();\nwrite!(&mut some_writer, \"{}\", format_args!(\"print with a {}\", \"macro\"));\n\nfn my_fmt_fn(args: fmt::Arguments) {\n    write!(&mut io::stdout(), \"{}\", args);\n}\nmy_fmt_fn(format_args!(\", or a {} too\", \"function\"));\n```\n\nThe result of the [`format_args!`] macro is a value of type [`fmt::Arguments`].\nThis structure can then be passed to the [`write`] and [`format`] functions\ninside this module in order to process the format string.\nThe goal of this macro is to even further prevent intermediate allocations\nwhen dealing with formatting strings.\n\nFor example, a logging library could use the standard formatting syntax, but\nit would internally pass around this structure until it has been determined\nwhere output should go to.\n\n[`fmt::Result`]: Result \"fmt::Result\"\n[Result]: core::result::Result \"std::result::Result\"\n[std::fmt::Error]: Error \"fmt::Error\"\n[`write`]: write() \"fmt::write\"\n[`to_string`]: crate::string::ToString::to_string \"ToString::to_string\"\n[`write_fmt`]: ../../std/io/trait.Write.html#method.write_fmt\n[`std::io::Write`]: ../../std/io/trait.Write.html\n[`print!`]: ../../std/macro.print.html \"print!\"\n[`println!`]: ../../std/macro.println.html \"println!\"\n[`eprint!`]: ../../std/macro.eprint.html \"eprint!\"\n[`eprintln!`]: ../../std/macro.eprintln.html \"eprintln!\"\n[`fmt::Arguments`]: Arguments \"fmt::Arguments\"\n[`format`]: format() \"fmt::format\""          },          filterText = "fmt",          kind = 9,          label = "fmt",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2934              },              start = {                character = 6,                line = 2934              }            },            newText = "fmt",            replace = {              end = {                character = 13,                line = 2934              },              start = {                character = 6,                line = 2934              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "abstract_prototypes",          kind = 9,          label = "abstract_prototypes",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2934              },              start = {                character = 6,                line = 2934              }            },            newText = "abstract_prototypes",            replace = {              end = {                character = 13,                line = 2934              },              start = {                character = 6,                line = 2934              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "prototype_type",          kind = 9,          label = "prototype_type",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2934              },              start = {                character = 6,                line = 2934              }            },            newText = "prototype_type",            replace = {              end = {                character = 13,                line = 2934              },              start = {                character = 6,                line = 2934              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "additional_types",          kind = 9,          label = "additional_types",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2934              },              start = {                character = 6,                line = 2934              }            },            newText = "additional_types",            replace = {              end = {                character = 13,                line = 2934              },              start = {                character = 6,                line = 2934              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "utility",          kind = 9,          label = "utility",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2934              },              start = {                character = 6,                line = 2934              }            },            newText = "utility",            replace = {              end = {                character = 13,                line = 2934              },              start = {                character = 6,                line = 2934              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "Extra iterator adaptors, functions and macros.\n\nTo extend [`Iterator`] with methods in this crate, import\nthe [`Itertools`] trait:\n\n```rust\nuse itertools::Itertools;\n```\n\nNow, new methods like [`interleave`](Itertools::interleave)\nare available on all iterators:\n\n```rust\nuse itertools::Itertools;\n\nlet it = (1..3).interleave(vec![-1, -2]);\nitertools::assert_equal(it, vec![1, -1, 2, -2]);\n```\n\nMost iterator methods are also provided as functions (with the benefit\nthat they convert parameters using [`IntoIterator`]):\n\n```rust\nuse itertools::interleave;\n\nfor elt in interleave(&[1, 2, 3], &[2, 3, 4]) {\n    /* loop body */\n}\n```\n\n## Crate Features\n\n- `use_std`\n  - Enabled by default.\n  - Disable to compile itertools using `#![no_std]`. This disables\n    any items that depend on collections (like `group_by`, `unique`,\n    `kmerge`, `join` and many more).\n\n## Rust Version\n\nThis version of itertools requires Rust 1.32 or later."          },          filterText = "itertools",          kind = 9,          label = "itertools",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2934              },              start = {                character = 6,                line = 2934              }            },            newText = "itertools",            replace = {              end = {                character = 13,                line = 2934              },              start = {                character = 6,                line = 2934              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "# High-level bindings to Lua\n\nThe `mlua` crate provides safe high-level bindings to the [Lua programming language].\n\n# The `Lua` object\n\nThe main type exported by this library is the [`Lua`] struct. In addition to methods for\n[executing] Lua chunks or [evaluating] Lua expressions, it provides methods for creating Lua\nvalues and accessing the table of [globals].\n\n# Converting data\n\nThe [`ToLua`] and [`FromLua`] traits allow conversion from Rust types to Lua values and vice\nversa. They are implemented for many data structures found in Rust's standard library.\n\nFor more general conversions, the [`ToLuaMulti`] and [`FromLuaMulti`] traits allow converting\nbetween Rust types and *any number* of Lua values.\n\nMost code in `mlua` is generic over implementors of those traits, so in most places the normal\nRust data structures are accepted without having to write any boilerplate.\n\n# Custom Userdata\n\nThe [`UserData`] trait can be implemented by user-defined types to make them available to Lua.\nMethods and operators to be used from Lua can be added using the [`UserDataMethods`] API.\nFields are supported using the [`UserDataFields`] API.\n\n# Serde support\n\nThe [`LuaSerdeExt`] trait implemented for [`Lua`] allows conversion from Rust types to Lua values\nand vice versa using serde. Any user defined data type that implements [`serde::Serialize`] or\n[`serde::Deserialize`] can be converted.\nFor convenience, additional functionality to handle `NULL` values and arrays is provided.\n\nThe [`Value`] enum implements [`serde::Serialize`] trait to support serializing Lua values\n(including [`UserData`]) into Rust values.\n\nRequires `feature = \"serialize\"`.\n\n# Async/await support\n\nThe [`create_async_function`] allows creating non-blocking functions that returns [`Future`].\nLua code with async capabilities can be executed by [`call_async`] family of functions or polling\n[`AsyncThread`] using any runtime (eg. Tokio).\n\nRequires `feature = \"async\"`.\n\n# `Send` requirement\nBy default `mlua` is `!Send`. This can be changed by enabling `feature = \"send\"` that adds `Send` requirement\nto [`Function`]s and [`UserData`].\n\n[Lua programming language]: https://www.lua.org/\n[`Lua`]: crate::Lua\n[executing]: crate::Chunk::exec\n[evaluating]: crate::Chunk::eval\n[globals]: crate::Lua::globals\n[`ToLua`]: crate::ToLua\n[`FromLua`]: crate::FromLua\n[`ToLuaMulti`]: crate::ToLuaMulti\n[`FromLuaMulti`]: crate::FromLuaMulti\n[`Function`]: crate::Function\n[`UserData`]: crate::UserData\n[`UserDataFields`]: crate::UserDataFields\n[`UserDataMethods`]: crate::UserDataMethods\n[`LuaSerdeExt`]: crate::LuaSerdeExt\n[`Value`]: crate::Value\n[`create_async_function`]: crate::Lua::create_async_function\n[`call_async`]: crate::Function::call_async\n[`AsyncThread`]: crate::AsyncThread\n[`Future`]: std::future::Future\n[`serde::Serialize`]: https://docs.serde.rs/serde/ser/trait.Serialize.html\n[`serde::Deserialize`]: https://docs.serde.rs/serde/de/trait.Deserialize.html"          },          filterText = "mlua",          kind = 9,          label = "mlua",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2934              },              start = {                character = 6,                line = 2934              }            },            newText = "mlua",            replace = {              end = {                character = 13,                line = 2934              },              start = {                character = 6,                line = 2934              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "# The Rust core allocation and collections library\n\nThis library provides smart pointers and collections for managing\nheap-allocated values.\n\nThis library, like libcore, normally doesn’t need to be used directly\nsince its contents are re-exported in the [`std` crate](../std/index.html).\nCrates that use the `#![no_std]` attribute however will typically\nnot depend on `std`, so they’d use this crate instead.\n\n## Boxed values\n\nThe [`Box`] type is a smart pointer type. There can only be one owner of a\n[`Box`], and the owner can decide to mutate the contents, which live on the\nheap.\n\nThis type can be sent among threads efficiently as the size of a `Box` value\nis the same as that of a pointer. Tree-like data structures are often built\nwith boxes because each node often has only one owner, the parent.\n\n## Reference counted pointers\n\nThe [`Rc`] type is a non-threadsafe reference-counted pointer type intended\nfor sharing memory within a thread. An [`Rc`] pointer wraps a type, `T`, and\nonly allows access to `&T`, a shared reference.\n\nThis type is useful when inherited mutability (such as using [`Box`]) is too\nconstraining for an application, and is often paired with the [`Cell`] or\n[`RefCell`] types in order to allow mutation.\n\n## Atomically reference counted pointers\n\nThe [`Arc`] type is the threadsafe equivalent of the [`Rc`] type. It\nprovides all the same functionality of [`Rc`], except it requires that the\ncontained type `T` is shareable. Additionally, [`Arc<T>`][`Arc`] is itself\nsendable while [`Rc<T>`][`Rc`] is not.\n\nThis type allows for shared access to the contained data, and is often\npaired with synchronization primitives such as mutexes to allow mutation of\nshared resources.\n\n## Collections\n\nImplementations of the most common general purpose data structures are\ndefined in this library. They are re-exported through the\n[standard collections library](../std/collections/index.html).\n\n## Heap interfaces\n\nThe [`alloc`](alloc/index.html) module defines the low-level interface to the\ndefault global allocator. It is not compatible with the libc allocator API.\n\n[`Arc`]: sync\n[`Box`]: boxed\n[`Cell`]: core::cell\n[`Rc`]: rc\n[`RefCell`]: core::cell"          },          filterText = "alloc",          kind = 9,          label = "alloc",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2934              },              start = {                character = 6,                line = 2934              }            },            newText = "alloc",            replace = {              end = {                character = 13,                line = 2934              },              start = {                character = 6,                line = 2934              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "This crate is not intended for use outside of [factorio-lib-rs]!"          },          filterText = "factorio_lib_rs_derive",          kind = 9,          label = "factorio_lib_rs_derive",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2934              },              start = {                character = 6,                line = 2934              }            },            newText = "factorio_lib_rs_derive",            replace = {              end = {                character = 13,                line = 2934              },              start = {                character = 6,                line = 2934              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = " Compile-time string formatting.\n\n This crate provides types and macros for formatting strings at compile-time.\n\n # Rust versions\n\n There are some features that require Rust 1.46.0,\n some that require Rust 1.51.0,\n and others that require Rust nightly,\n the sections below describe the features that are available for each version.\n\n ### Rust 1.46.0\n\n These macros are the only things available in Rust 1.46.0:\n\n - [`concatcp`]:\n Concatenates `integers`, `bool`, `char`, and `&str` constants into a `&'static str` constant.\n\n - [`formatcp`]:\n [`format`]-like formatting which takes `integers`, `bool`, `char`, and `&str` constants,\n and emits a `&'static str` constant.\n\n - [`str_get`]:\n Indexes a `&'static str` constant, returning `None` when the index is out of bounds.\n\n - [`str_index`]:\n Indexes a `&'static str` constant.\n\n - [`str_repeat`]:\n Creates a `&'static str` by repeating a `&'static str` constant `times` times.\n\n - [`str_splice`]:\n Replaces a substring in a `&'static str` constant.\n\n\n ### Rust 1.51.0\n\n By enabling the \"const_generics\" feature, you can use these macros:\n\n - [`map_ascii_case`]:\n Converts a `&'static str` constant to a different casing style,\n determined by a [`Case`] argument.\n\n - [`str_replace`]:\n Replaces all the instances of a pattern in a `&'static str` constant with\n another `&'static str` constant.\n\n ### Rust 1.57.0\n\n The \"assertcp\" feature enables the [`assertcp`], [`assertcp_eq`],\n and [`assertcp_ne`] macros.\n These macros are like the standard library assert macros,\n but evaluated at compile-time,\n with the limitation that they can only have primitive types as arguments\n (just like [`concatcp`] and [`formatcp`]).\n\n ### Rust nightly\n\n By enabling the \"fmt\" feature, you can use a [`std::fmt`]-like API.\n\n This requires the nightly compiler because it uses mutable references in const fn,\n which have not been stabilized as of writing these docs.\n\n All the other features of this crate are implemented on top of the [`const_format::fmt`] API:\n\n - [`concatc`]:\n Concatenates many standard library and user defined types into a `&'static str` constant.\n\n - [`formatc`]:\n [`format`]-like macro that can format many standard library and user defined types into\n a `&'static str` constant.\n\n - [`writec`]:\n [`write`]-like macro that can format many standard library and user defined types\n into a type that implements [`WriteMarker`].\n\n The \"derive\" feature enables the [`ConstDebug`] macro,\n and the \"fmt\" feature.<br>\n [`ConstDebug`] derives the [`FormatMarker`] trait,\n and implements an inherent `const_debug_fmt` method for compile-time debug formatting.\n\n The \"assertc\" feature enables the [`assertc`], [`assertc_eq`], [`assertc_ne`] macros,\n and the \"fmt\" feature.<br>\n These macros are like the standard library assert macros, but evaluated at compile-time.\n # Examples\n\n ### Concatenation of primitive types\n\n This example works in Rust 1.46.0.\n\n ```rust\n use const_format::concatcp;\n\n const NAME: &str = \"Bob\";\n const FOO: &str = concatcp!(NAME, \", age \", 21u8,\"!\");\n\n assert_eq!(FOO, \"Bob, age 21!\");\n ```\n\n ### Formatting primitive types\n\n This example works in Rust 1.46.0.\n\n ```rust\n use const_format::formatcp;\n\n const NAME: &str = \"John\";\n\n const FOO: &str = formatcp!(\"{NAME}, age {}!\", compute_age(NAME));\n\n assert_eq!(FOO, \"John, age 24!\");\n\n # const fn compute_age(s: &str) -> usize { s.len() * 6 }\n\n ```\n\n ### Formatting custom types\n\n This example demonstrates how you can use the [`ConstDebug`] derive macro,\n and then format the type into a `&'static str` constant.\n\n This example requires Rust nightly, and the \"derive\" feature.\n\n```rust\n #![feature(const_mut_refs)]\n\n use const_format::{ConstDebug, formatc};\n\n #[derive(ConstDebug)]\n struct Message{\n     ip: [Octet; 4],\n     value: &'static str,\n }\n\n #[derive(ConstDebug)]\n struct Octet(u8);\n\n const MSG: Message = Message{\n     ip: [Octet(127), Octet(0), Octet(0), Octet(1)],\n     value: \"Hello, World!\",\n };\n\n const FOO: &str = formatc!(\"{:?}\", MSG);\n\n assert_eq!(\n     FOO,\n     \"Message { ip: [Octet(127), Octet(0), Octet(0), Octet(1)], value: \\\"Hello, World!\\\" }\"\n );\n\n ```\n\n## Formatted const assertions\n\n This example demonstrates how you can use the [`assertcp_ne`] macro to\n do compile-time inequality assertions with formatted error messages.\n\n This requires the \"assertcp\" feature,\n because using the `panic` macro at compile-time requires Rust 1.57.0.\n\n```ignore\n #![feature(const_mut_refs)]\n\n use const_format::assertcp_ne;\n\n macro_rules! check_valid_pizza{\n     ($user:expr, $topping:expr) => {\n         assertcp_ne!(\n             $topping,\n             \"pineapple\",\n             \"You can't put pineapple on pizza, {}\",\n             $user,\n         );\n     }\n }\n\n check_valid_pizza!(\"John\", \"salami\");\n check_valid_pizza!(\"Dave\", \"sausage\");\n check_valid_pizza!(\"Bob\", \"pineapple\");\n\n # fn main(){}\n ```\n\n This is the compiler output:\n\n ```text\n error[E0080]: evaluation of constant value failed\n   --> src/lib.rs:178:27\n    |\n 20 | check_valid_pizza!(\"Bob\", \"pineapple\");\n    |                           ^^^^^^^^^^^ the evaluated program panicked at '\n assertion failed: `(left != right)`\n  left: `\"pineapple\"`\n right: `\"pineapple\"`\n You can't put pineapple on pizza, Bob\n ', src/lib.rs:20:27\n\n\n ```\n\n <div id=\"macro-limitations\"></div>\n\n # Limitations\n\n All of the macros from `const_format` have these limitations:\n\n - The formatting macros that expand to\n `&'static str`s can only use constants from concrete types,\n so while a `Type::<u8>::FOO` argument would be fine,\n `Type::<T>::FOO` would not be (`T` being a type parameter).\n\n - Integer arguments must have a type inferrable from context,\n [more details in the Integer arguments section](#integer-args).\n\n - They cannot be used places that take string literals.\n So `#[doc = \"foobar\"]` cannot be replaced with `#[doc = concatcp!(\"foo\", \"bar\") ]`.\n\n <span id=\"integer-args\"></span>\n\n ### Integer arguments\n\n Integer arguments must have a type inferrable from context.\n so if you only pass an integer literal it must have a suffix.\n\n Example of what does compile:\n\n ```rust\n const N: u32 = 1;\n assert_eq!(const_format::concatcp!(N + 1, 2 + N), \"23\");\n\n assert_eq!(const_format::concatcp!(2u32, 2 + 1u8, 3u8 + 1), \"234\");\n ```\n\n Example of what does not compile:\n ```compile_fail\n assert_eq!(const_format::concatcp!(1 + 1, 2 + 1), \"23\");\n ```\n\n # Renaming crate\n\n All function-like macros from `const_format` can be used when the crate is renamed.\n\n The [`ConstDebug`] derive macro has the `#[cdeb(crate = \"foo::bar\")]` attribute to\n tell it where to find the `const_format` crate.\n\n Example of renaming the `const_format` crate in the Cargo.toml file:\n ```toml\n cfmt = {version = \"0.*\", package = \"const_format\"}\n ```\n\n # Cargo features\n\n - \"fmt\": Enables the [`std::fmt`]-like API,\n requires Rust nightly because it uses mutable references in const fn.<br>\n This feature includes the [`formatc`]/[`writec`] formatting macros.\n\n - \"derive\": implies the \"fmt\" feature,\n provides the [`ConstDebug`] derive macro to format user-defined types at compile-time.<br>\n This implicitly uses the `syn` crate, so clean compiles take a bit longer than without the feature.\n\n - \"assertc\": implies the \"fmt\" feature,\n enables the [`assertc`], [`assertc_eq`], and [`assertc_ne`] assertion macros.<br>\n This feature was previously named \"assert\",\n but it was renamed to avoid confusion with the \"assertcp\" feature.\n\n - \"assertcp\": Requires Rust 1.57.0, implies the \"const_generics\" feature.\n Enables the [`assertcp`], [`assertcp_eq`], and [`assertcp_ne`] assertion macros.\n\n - \"constant_time_as_str\": implies the \"fmt\" feature.\n An optimization that requires a few additional nightly features,\n allowing the `as_bytes_alt` methods and `slice_up_to_len_alt` methods to run\n in constant time, rather than linear time proportional to the truncated part of the slice.\n\n - \"const_generics\": Requires Rust 1.51.0.\n Enables the macros listed in the [Rust 1.51.0](#rust-1510) section.\n Also changes the the implementation of the [`concatcp`] and [`formatcp`]\n macros to use const generics.\n\n\n\n # No-std support\n\n `const_format` is unconditionally `#![no_std]`, it can be used anywhere Rust can be used.\n\n # Minimum Supported Rust Version\n\n `const_format` requires Rust 1.46.0, because it uses looping an branching in const contexts.\n\n Features that require newer versions of Rust, or the nightly compiler,\n need to be explicitly enabled with cargo features.\n\n\n [`assertc`]: ./macro.assertc.html\n\n [`assertc_eq`]: ./macro.assertc_eq.html\n\n [`assertc_ne`]: ./macro.assertc_ne.html\n\n [`assertcp`]: ./macro.assertcp.html\n\n [`assertcp_eq`]: ./macro.assertcp_eq.html\n\n [`assertcp_ne`]: ./macro.assertcp_ne.html\n\n [`concatcp`]: ./macro.concatcp.html\n\n [`formatcp`]: ./macro.formatcp.html\n\n [`format`]: https://doc.rust-lang.org/std/macro.format.html\n\n [`std::fmt`]: https://doc.rust-lang.org/std/fmt/index.html\n\n [`const_format::fmt`]: ./fmt/index.html\n\n [`concatc`]: ./macro.concatc.html\n\n [`formatc`]: ./macro.formatc.html\n\n [`writec`]: ./macro.writec.html\n\n [`write`]: https://doc.rust-lang.org/std/macro.write.html\n\n [`Formatter`]: ./fmt/struct.Formatter.html\n\n [`StrWriter`]: ./fmt/struct.StrWriter.html\n\n [`ConstDebug`]: ./derive.ConstDebug.html\n\n [`FormatMarker`]: ./marker_traits/trait.FormatMarker.html\n\n [`WriteMarker`]: ./marker_traits/trait.WriteMarker.html\n\n [`map_ascii_case`]: ./macro.map_ascii_case.html\n\n [`Case`]: ./enum.Case.html\n\n\n [`str_get`]: ./macro.str_get.html\n\n [`str_index`]: ./macro.str_index.html\n\n [`str_repeat`]: ./macro.str_repeat.html\n\n [`str_splice`]: ./macro.str_splice.html\n\n [`str_replace`]: ./macro.str_replace.html\n\n [`str::replace`]: https://doc.rust-lang.org/std/primitive.str.html#method.replace"          },          filterText = "const_format",          kind = 9,          label = "const_format",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2934              },              start = {                character = 6,                line = 2934              }            },            newText = "const_format",            replace = {              end = {                character = 13,                line = 2934              },              start = {                character = 6,                line = 2934              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = 'Ini parser for Rust\n\n```rust\nuse ini::Ini;\n\nlet mut conf = Ini::new();\nconf.with_section(Some("User"))\n    .set("name", "Raspberry树莓")\n    .set("value", "Pi");\nconf.with_section(Some("Library"))\n    .set("name", "Sun Yat-sen U")\n    .set("location", "Guangzhou=world");\nconf.write_to_file("conf.ini").unwrap();\n\nlet i = Ini::load_from_file("conf.ini").unwrap();\nfor (sec, prop) in i.iter() {\n    println!("Section: {:?}", sec);\n    for (k, v) in prop.iter() {\n        println!("{}:{}", k, v);\n    }\n}\n```'          },          filterText = "ini",          kind = 9,          label = "ini",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2934              },              start = {                character = 6,                line = 2934              }            },            newText = "ini",            replace = {              end = {                character = 13,                line = 2934              },              start = {                character = 6,                line = 2934              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "\nThis crate provides a library for parsing, compiling, and executing regular\nexpressions. Its syntax is similar to Perl-style regular expressions, but lacks\na few features like look around and backreferences. In exchange, all searches\nexecute in linear time with respect to the size of the regular expression and\nsearch text.\n\nThis crate's documentation provides some simple examples, describes\n[Unicode support](#unicode) and exhaustively lists the\n[supported syntax](#syntax).\n\nFor more specific details on the API for regular expressions, please see the\ndocumentation for the [`Regex`](struct.Regex.html) type.\n\n# Usage\n\nThis crate is [on crates.io](https://crates.io/crates/regex) and can be\nused by adding `regex` to your dependencies in your project's `Cargo.toml`.\n\n```toml\n[dependencies]\nregex = \"1\"\n```\n\n# Example: find a date\n\nGeneral use of regular expressions in this package involves compiling an\nexpression and then using it to search, split or replace text. For example,\nto confirm that some text resembles a date:\n\n```rust\nuse regex::Regex;\nlet re = Regex::new(r\"^\\d{4}-\\d{2}-\\d{2}$\").unwrap();\nassert!(re.is_match(\"2014-01-01\"));\n```\n\nNotice the use of the `^` and `$` anchors. In this crate, every expression\nis executed with an implicit `.*?` at the beginning and end, which allows\nit to match anywhere in the text. Anchors can be used to ensure that the\nfull text matches an expression.\n\nThis example also demonstrates the utility of\n[raw strings](https://doc.rust-lang.org/stable/reference/tokens.html#raw-string-literals)\nin Rust, which\nare just like regular strings except they are prefixed with an `r` and do\nnot process any escape sequences. For example, `\"\\\\d\"` is the same\nexpression as `r\"\\d\"`.\n\n# Example: Avoid compiling the same regex in a loop\n\nIt is an anti-pattern to compile the same regular expression in a loop\nsince compilation is typically expensive. (It takes anywhere from a few\nmicroseconds to a few **milliseconds** depending on the size of the\nregex.) Not only is compilation itself expensive, but this also prevents\noptimizations that reuse allocations internally to the matching engines.\n\nIn Rust, it can sometimes be a pain to pass regular expressions around if\nthey're used from inside a helper function. Instead, we recommend using the\n[`lazy_static`](https://crates.io/crates/lazy_static) crate to ensure that\nregular expressions are compiled exactly once.\n\nFor example:\n\n```rust\nuse lazy_static::lazy_static;\nuse regex::Regex;\n\nfn some_helper_function(text: &str) -> bool {\n    lazy_static! {\n        static ref RE: Regex = Regex::new(\"...\").unwrap();\n    }\n    RE.is_match(text)\n}\n\nfn main() {}\n```\n\nSpecifically, in this example, the regex will be compiled when it is used for\nthe first time. On subsequent uses, it will reuse the previous compilation.\n\n# Example: iterating over capture groups\n\nThis crate provides convenient iterators for matching an expression\nrepeatedly against a search string to find successive non-overlapping\nmatches. For example, to find all dates in a string and be able to access\nthem by their component pieces:\n\n```rust\nlet re = Regex::new(r\"(\\d{4})-(\\d{2})-(\\d{2})\").unwrap();\nlet text = \"2012-03-14, 2013-01-01 and 2014-07-05\";\nfor cap in re.captures_iter(text) {\n    println!(\"Month: {} Day: {} Year: {}\", &cap[2], &cap[3], &cap[1]);\n}\n// Output:\n// Month: 03 Day: 14 Year: 2012\n// Month: 01 Day: 01 Year: 2013\n// Month: 07 Day: 05 Year: 2014\n```\n\nNotice that the year is in the capture group indexed at `1`. This is\nbecause the *entire match* is stored in the capture group at index `0`.\n\n# Example: replacement with named capture groups\n\nBuilding on the previous example, perhaps we'd like to rearrange the date\nformats. This can be done with text replacement. But to make the code\nclearer, we can *name*  our capture groups and use those names as variables\nin our replacement text:\n\n```rust\nlet re = Regex::new(r\"(?P<y>\\d{4})-(?P<m>\\d{2})-(?P<d>\\d{2})\").unwrap();\nlet before = \"2012-03-14, 2013-01-01 and 2014-07-05\";\nlet after = re.replace_all(before, \"$m/$d/$y\");\nassert_eq!(after, \"03/14/2012, 01/01/2013 and 07/05/2014\");\n```\n\nThe `replace` methods are actually polymorphic in the replacement, which\nprovides more flexibility than is seen here. (See the documentation for\n`Regex::replace` for more details.)\n\nNote that if your regex gets complicated, you can use the `x` flag to\nenable insignificant whitespace mode, which also lets you write comments:\n\n```rust\nlet re = Regex::new(r\"(?x)\n  (?P<y>\\d{4}) # the year\n  -\n  (?P<m>\\d{2}) # the month\n  -\n  (?P<d>\\d{2}) # the day\n\").unwrap();\nlet before = \"2012-03-14, 2013-01-01 and 2014-07-05\";\nlet after = re.replace_all(before, \"$m/$d/$y\");\nassert_eq!(after, \"03/14/2012, 01/01/2013 and 07/05/2014\");\n```\n\nIf you wish to match against whitespace in this mode, you can still use `\\s`,\n`\\n`, `\\t`, etc. For escaping a single space character, you can escape it\ndirectly with `\\ `, use its hex character code `\\x20` or temporarily disable\nthe `x` flag, e.g., `(?-x: )`.\n\n# Example: match multiple regular expressions simultaneously\n\nThis demonstrates how to use a `RegexSet` to match multiple (possibly\noverlapping) regular expressions in a single scan of the search text:\n\n```rust\nuse regex::RegexSet;\n\nlet set = RegexSet::new(&[\n    r\"\\w+\",\n    r\"\\d+\",\n    r\"\\pL+\",\n    r\"foo\",\n    r\"bar\",\n    r\"barfoo\",\n    r\"foobar\",\n]).unwrap();\n\n// Iterate over and collect all of the matches.\nlet matches: Vec<_> = set.matches(\"foobar\").into_iter().collect();\nassert_eq!(matches, vec![0, 2, 3, 4, 6]);\n\n// You can also test whether a particular regex matched:\nlet matches = set.matches(\"foobar\");\nassert!(!matches.matched(5));\nassert!(matches.matched(6));\n```\n\n# Pay for what you use\n\nWith respect to searching text with a regular expression, there are three\nquestions that can be asked:\n\n1. Does the text match this expression?\n2. If so, where does it match?\n3. Where did the capturing groups match?\n\nGenerally speaking, this crate could provide a function to answer only #3,\nwhich would subsume #1 and #2 automatically. However, it can be significantly\nmore expensive to compute the location of capturing group matches, so it's best\nnot to do it if you don't need to.\n\nTherefore, only use what you need. For example, don't use `find` if you\nonly need to test if an expression matches a string. (Use `is_match`\ninstead.)\n\n# Unicode\n\nThis implementation executes regular expressions **only** on valid UTF-8\nwhile exposing match locations as byte indices into the search string. (To\nrelax this restriction, use the [`bytes`](bytes/index.html) sub-module.)\n\nOnly simple case folding is supported. Namely, when matching\ncase-insensitively, the characters are first mapped using the \"simple\" case\nfolding rules defined by Unicode.\n\nRegular expressions themselves are **only** interpreted as a sequence of\nUnicode scalar values. This means you can use Unicode characters directly\nin your expression:\n\n```rust\nlet re = Regex::new(r\"(?i)Δ+\").unwrap();\nlet mat = re.find(\"ΔδΔ\").unwrap();\nassert_eq!((mat.start(), mat.end()), (0, 6));\n```\n\nMost features of the regular expressions in this crate are Unicode aware. Here\nare some examples:\n\n* `.` will match any valid UTF-8 encoded Unicode scalar value except for `\\n`.\n  (To also match `\\n`, enable the `s` flag, e.g., `(?s:.)`.)\n* `\\w`, `\\d` and `\\s` are Unicode aware. For example, `\\s` will match all forms\n  of whitespace categorized by Unicode.\n* `\\b` matches a Unicode word boundary.\n* Negated character classes like `[^a]` match all Unicode scalar values except\n  for `a`.\n* `^` and `$` are **not** Unicode aware in multi-line mode. Namely, they only\n  recognize `\\n` and not any of the other forms of line terminators defined\n  by Unicode.\n\nUnicode general categories, scripts, script extensions, ages and a smattering\nof boolean properties are available as character classes. For example, you can\nmatch a sequence of numerals, Greek or Cherokee letters:\n\n```rust\nlet re = Regex::new(r\"[\\pN\\p{Greek}\\p{Cherokee}]+\").unwrap();\nlet mat = re.find(\"abcΔᎠβⅠᏴγδⅡxyz\").unwrap();\nassert_eq!((mat.start(), mat.end()), (3, 23));\n```\n\nFor a more detailed breakdown of Unicode support with respect to\n[UTS#18](https://unicode.org/reports/tr18/),\nplease see the\n[UNICODE](https://github.com/rust-lang/regex/blob/master/UNICODE.md)\ndocument in the root of the regex repository.\n\n# Opt out of Unicode support\n\nThe `bytes` sub-module provides a `Regex` type that can be used to match\non `&[u8]`. By default, text is interpreted as UTF-8 just like it is with\nthe main `Regex` type. However, this behavior can be disabled by turning\noff the `u` flag, even if doing so could result in matching invalid UTF-8.\nFor example, when the `u` flag is disabled, `.` will match any byte instead\nof any Unicode scalar value.\n\nDisabling the `u` flag is also possible with the standard `&str`-based `Regex`\ntype, but it is only allowed where the UTF-8 invariant is maintained. For\nexample, `(?-u:\\w)` is an ASCII-only `\\w` character class and is legal in an\n`&str`-based `Regex`, but `(?-u:\\xFF)` will attempt to match the raw byte\n`\\xFF`, which is invalid UTF-8 and therefore is illegal in `&str`-based\nregexes.\n\nFinally, since Unicode support requires bundling large Unicode data\ntables, this crate exposes knobs to disable the compilation of those\ndata tables, which can be useful for shrinking binary size and reducing\ncompilation times. For details on how to do that, see the section on [crate\nfeatures](#crate-features).\n\n# Syntax\n\nThe syntax supported in this crate is documented below.\n\nNote that the regular expression parser and abstract syntax are exposed in\na separate crate, [`regex-syntax`](https://docs.rs/regex-syntax).\n\n## Matching one character\n\n<pre class=\"rust\">\n.             any character except new line (includes new line with s flag)\n\\d            digit (\\p{Nd})\n\\D            not digit\n\\pN           One-letter name Unicode character class\n\\p{Greek}     Unicode character class (general category or script)\n\\PN           Negated one-letter name Unicode character class\n\\P{Greek}     negated Unicode character class (general category or script)\n</pre>\n\n### Character classes\n\n<pre class=\"rust\">\n[xyz]         A character class matching either x, y or z (union).\n[^xyz]        A character class matching any character except x, y and z.\n[a-z]         A character class matching any character in range a-z.\n[[:alpha:]]   ASCII character class ([A-Za-z])\n[[:^alpha:]]  Negated ASCII character class ([^A-Za-z])\n[x[^xyz]]     Nested/grouping character class (matching any character except y and z)\n[a-y&&xyz]    Intersection (matching x or y)\n[0-9&&[^4]]   Subtraction using intersection and negation (matching 0-9 except 4)\n[0-9--4]      Direct subtraction (matching 0-9 except 4)\n[a-g~~b-h]    Symmetric difference (matching `a` and `h` only)\n[\\[\\]]        Escaping in character classes (matching [ or ])\n</pre>\n\nAny named character class may appear inside a bracketed `[...]` character\nclass. For example, `[\\p{Greek}[:digit:]]` matches any Greek or ASCII\ndigit. `[\\p{Greek}&&\\pL]` matches Greek letters.\n\nPrecedence in character classes, from most binding to least:\n\n1. Ranges: `a-cd` == `[a-c]d`\n2. Union: `ab&&bc` == `[ab]&&[bc]`\n3. Intersection: `^a-z&&b` == `^[a-z&&b]`\n4. Negation\n\n## Composites\n\n<pre class=\"rust\">\nxy    concatenation (x followed by y)\nx|y   alternation (x or y, prefer x)\n</pre>\n\n## Repetitions\n\n<pre class=\"rust\">\nx*        zero or more of x (greedy)\nx+        one or more of x (greedy)\nx?        zero or one of x (greedy)\nx*?       zero or more of x (ungreedy/lazy)\nx+?       one or more of x (ungreedy/lazy)\nx??       zero or one of x (ungreedy/lazy)\nx{n,m}    at least n x and at most m x (greedy)\nx{n,}     at least n x (greedy)\nx{n}      exactly n x\nx{n,m}?   at least n x and at most m x (ungreedy/lazy)\nx{n,}?    at least n x (ungreedy/lazy)\nx{n}?     exactly n x\n</pre>\n\n## Empty matches\n\n<pre class=\"rust\">\n^     the beginning of text (or start-of-line with multi-line mode)\n$     the end of text (or end-of-line with multi-line mode)\n\\A    only the beginning of text (even with multi-line mode enabled)\n\\z    only the end of text (even with multi-line mode enabled)\n\\b    a Unicode word boundary (\\w on one side and \\W, \\A, or \\z on other)\n\\B    not a Unicode word boundary\n</pre>\n\n## Grouping and flags\n\n<pre class=\"rust\">\n(exp)          numbered capture group (indexed by opening parenthesis)\n(?P&lt;name&gt;exp)  named (also numbered) capture group (allowed chars: [_0-9a-zA-Z.\\[\\]])\n(?:exp)        non-capturing group\n(?flags)       set flags within current group\n(?flags:exp)   set flags for exp (non-capturing)\n</pre>\n\nFlags are each a single character. For example, `(?x)` sets the flag `x`\nand `(?-x)` clears the flag `x`. Multiple flags can be set or cleared at\nthe same time: `(?xy)` sets both the `x` and `y` flags and `(?x-y)` sets\nthe `x` flag and clears the `y` flag.\n\nAll flags are by default disabled unless stated otherwise. They are:\n\n<pre class=\"rust\">\ni     case-insensitive: letters match both upper and lower case\nm     multi-line mode: ^ and $ match begin/end of line\ns     allow . to match \\n\nU     swap the meaning of x* and x*?\nu     Unicode support (enabled by default)\nx     ignore whitespace and allow line comments (starting with `#`)\n</pre>\n\nFlags can be toggled within a pattern. Here's an example that matches\ncase-insensitively for the first part but case-sensitively for the second part:\n\n```rust\nlet re = Regex::new(r\"(?i)a+(?-i)b+\").unwrap();\nlet cap = re.captures(\"AaAaAbbBBBb\").unwrap();\nassert_eq!(&cap[0], \"AaAaAbb\");\n```\n\nNotice that the `a+` matches either `a` or `A`, but the `b+` only matches\n`b`.\n\nMulti-line mode means `^` and `$` no longer match just at the beginning/end of\nthe input, but at the beginning/end of lines:\n\n```rust\nlet re = Regex::new(r\"(?m)^line \\d+\").unwrap();\nlet m = re.find(\"line one\\nline 2\\n\").unwrap();\nassert_eq!(m.as_str(), \"line 2\");\n```\n\nNote that `^` matches after new lines, even at the end of input:\n\n```rust\nlet re = Regex::new(r\"(?m)^\").unwrap();\nlet m = re.find_iter(\"test\\n\").last().unwrap();\nassert_eq!((m.start(), m.end()), (5, 5));\n```\n\nHere is an example that uses an ASCII word boundary instead of a Unicode\nword boundary:\n\n```rust\nlet re = Regex::new(r\"(?-u:\\b).+(?-u:\\b)\").unwrap();\nlet cap = re.captures(\"$$abc$$\").unwrap();\nassert_eq!(&cap[0], \"abc\");\n```\n\n## Escape sequences\n\n<pre class=\"rust\">\n\\*          literal *, works for any punctuation character: \\.+*?()|[]{}^$\n\\a          bell (\\x07)\n\\f          form feed (\\x0C)\n\\t          horizontal tab\n\\n          new line\n\\r          carriage return\n\\v          vertical tab (\\x0B)\n\\123        octal character code (up to three digits) (when enabled)\n\\x7F        hex character code (exactly two digits)\n\\x{10FFFF}  any hex character code corresponding to a Unicode code point\n\\u007F      hex character code (exactly four digits)\n\\u{7F}      any hex character code corresponding to a Unicode code point\n\\U0000007F  hex character code (exactly eight digits)\n\\U{7F}      any hex character code corresponding to a Unicode code point\n</pre>\n\n## Perl character classes (Unicode friendly)\n\nThese classes are based on the definitions provided in\n[UTS#18](https://www.unicode.org/reports/tr18/#Compatibility_Properties):\n\n<pre class=\"rust\">\n\\d     digit (\\p{Nd})\n\\D     not digit\n\\s     whitespace (\\p{White_Space})\n\\S     not whitespace\n\\w     word character (\\p{Alphabetic} + \\p{M} + \\d + \\p{Pc} + \\p{Join_Control})\n\\W     not word character\n</pre>\n\n## ASCII character classes\n\n<pre class=\"rust\">\n[[:alnum:]]    alphanumeric ([0-9A-Za-z])\n[[:alpha:]]    alphabetic ([A-Za-z])\n[[:ascii:]]    ASCII ([\\x00-\\x7F])\n[[:blank:]]    blank ([\\t ])\n[[:cntrl:]]    control ([\\x00-\\x1F\\x7F])\n[[:digit:]]    digits ([0-9])\n[[:graph:]]    graphical ([!-~])\n[[:lower:]]    lower case ([a-z])\n[[:print:]]    printable ([ -~])\n[[:punct:]]    punctuation ([!-/:-@\\[-`{-~])\n[[:space:]]    whitespace ([\\t\\n\\v\\f\\r ])\n[[:upper:]]    upper case ([A-Z])\n[[:word:]]     word characters ([0-9A-Za-z_])\n[[:xdigit:]]   hex digit ([0-9A-Fa-f])\n</pre>\n\n# Crate features\n\nBy default, this crate tries pretty hard to make regex matching both as fast\nas possible and as correct as it can be, within reason. This means that there\nis a lot of code dedicated to performance, the handling of Unicode data and the\nUnicode data itself. Overall, this leads to more dependencies, larger binaries\nand longer compile times.  This trade off may not be appropriate in all cases,\nand indeed, even when all Unicode and performance features are disabled, one\nis still left with a perfectly serviceable regex engine that will work well\nin many cases.\n\nThis crate exposes a number of features for controlling that trade off. Some\nof these features are strictly performance oriented, such that disabling them\nwon't result in a loss of functionality, but may result in worse performance.\nOther features, such as the ones controlling the presence or absence of Unicode\ndata, can result in a loss of functionality. For example, if one disables the\n`unicode-case` feature (described below), then compiling the regex `(?i)a`\nwill fail since Unicode case insensitivity is enabled by default. Instead,\ncallers must use `(?i-u)a` instead to disable Unicode case folding. Stated\ndifferently, enabling or disabling any of the features below can only add or\nsubtract from the total set of valid regular expressions. Enabling or disabling\na feature will never modify the match semantics of a regular expression.\n\nAll features below are enabled by default.\n\n### Ecosystem features\n\n* **std** -\n  When enabled, this will cause `regex` to use the standard library. Currently,\n  disabling this feature will always result in a compilation error. It is\n  intended to add `alloc`-only support to regex in the future.\n\n### Performance features\n\n* **perf** -\n  Enables all performance related features. This feature is enabled by default\n  and will always cover all features that improve performance, even if more\n  are added in the future.\n* **perf-dfa** -\n  Enables the use of a lazy DFA for matching. The lazy DFA is used to compile\n  portions of a regex to a very fast DFA on an as-needed basis. This can\n  result in substantial speedups, usually by an order of magnitude on large\n  haystacks. The lazy DFA does not bring in any new dependencies, but it can\n  make compile times longer.\n* **perf-inline** -\n  Enables the use of aggressive inlining inside match routines. This reduces\n  the overhead of each match. The aggressive inlining, however, increases\n  compile times and binary size.\n* **perf-literal** -\n  Enables the use of literal optimizations for speeding up matches. In some\n  cases, literal optimizations can result in speedups of _several_ orders of\n  magnitude. Disabling this drops the `aho-corasick` and `memchr` dependencies.\n* **perf-cache** -\n  This feature used to enable a faster internal cache at the cost of using\n  additional dependencies, but this is no longer an option. A fast internal\n  cache is now used unconditionally with no additional dependencies. This may\n  change in the future.\n\n### Unicode features\n\n* **unicode** -\n  Enables all Unicode features. This feature is enabled by default, and will\n  always cover all Unicode features, even if more are added in the future.\n* **unicode-age** -\n  Provide the data for the\n  [Unicode `Age` property](https://www.unicode.org/reports/tr44/tr44-24.html#Character_Age).\n  This makes it possible to use classes like `\\p{Age:6.0}` to refer to all\n  codepoints first introduced in Unicode 6.0\n* **unicode-bool** -\n  Provide the data for numerous Unicode boolean properties. The full list\n  is not included here, but contains properties like `Alphabetic`, `Emoji`,\n  `Lowercase`, `Math`, `Uppercase` and `White_Space`.\n* **unicode-case** -\n  Provide the data for case insensitive matching using\n  [Unicode's \"simple loose matches\" specification](https://www.unicode.org/reports/tr18/#Simple_Loose_Matches).\n* **unicode-gencat** -\n  Provide the data for\n  [Unicode general categories](https://www.unicode.org/reports/tr44/tr44-24.html#General_Category_Values).\n  This includes, but is not limited to, `Decimal_Number`, `Letter`,\n  `Math_Symbol`, `Number` and `Punctuation`.\n* **unicode-perl** -\n  Provide the data for supporting the Unicode-aware Perl character classes,\n  corresponding to `\\w`, `\\s` and `\\d`. This is also necessary for using\n  Unicode-aware word boundary assertions. Note that if this feature is\n  disabled, the `\\s` and `\\d` character classes are still available if the\n  `unicode-bool` and `unicode-gencat` features are enabled, respectively.\n* **unicode-script** -\n  Provide the data for\n  [Unicode scripts and script extensions](https://www.unicode.org/reports/tr24/).\n  This includes, but is not limited to, `Arabic`, `Cyrillic`, `Hebrew`,\n  `Latin` and `Thai`.\n* **unicode-segment** -\n  Provide the data necessary to provide the properties used to implement the\n  [Unicode text segmentation algorithms](https://www.unicode.org/reports/tr29/).\n  This enables using classes like `\\p{gcb=Extend}`, `\\p{wb=Katakana}` and\n  `\\p{sb=ATerm}`.\n\n\n# Untrusted input\n\nThis crate can handle both untrusted regular expressions and untrusted\nsearch text.\n\nUntrusted regular expressions are handled by capping the size of a compiled\nregular expression.\n(See [`RegexBuilder::size_limit`](struct.RegexBuilder.html#method.size_limit).)\nWithout this, it would be trivial for an attacker to exhaust your system's\nmemory with expressions like `a{100}{100}{100}`.\n\nUntrusted search text is allowed because the matching engine(s) in this\ncrate have time complexity `O(mn)` (with `m ~ regex` and `n ~ search\ntext`), which means there's no way to cause exponential blow-up like with\nsome other regular expression engines. (We pay for this by disallowing\nfeatures like arbitrary look-ahead and backreferences.)\n\nWhen a DFA is used, pathological cases with exponential state blow-up are\navoided by constructing the DFA lazily or in an \"online\" manner. Therefore,\nat most one new state can be created for each byte of input. This satisfies\nour time complexity guarantees, but can lead to memory growth\nproportional to the size of the input. As a stopgap, the DFA is only\nallowed to store a fixed number of states. When the limit is reached, its\nstates are wiped and continues on, possibly duplicating previous work. If\nthe limit is reached too frequently, it gives up and hands control off to\nanother matching engine with fixed memory requirements.\n(The DFA size limit can also be tweaked. See\n[`RegexBuilder::dfa_size_limit`](struct.RegexBuilder.html#method.dfa_size_limit).)"          },          filterText = "regex",          kind = 9,          label = "regex",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2934              },              start = {                character = 6,                line = 2934              }            },            newText = "regex",            replace = {              end = {                character = 13,                line = 2934              },              start = {                character = 6,                line = 2934              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "# Serde\n\nSerde is a framework for ***ser***ializing and ***de***serializing Rust data\nstructures efficiently and generically.\n\nThe Serde ecosystem consists of data structures that know how to serialize\nand deserialize themselves along with data formats that know how to\nserialize and deserialize other things. Serde provides the layer by which\nthese two groups interact with each other, allowing any supported data\nstructure to be serialized and deserialized using any supported data format.\n\nSee the Serde website <https://serde.rs/> for additional documentation and\nusage examples.\n\n## Design\n\nWhere many other languages rely on runtime reflection for serializing data,\nSerde is instead built on Rust's powerful trait system. A data structure\nthat knows how to serialize and deserialize itself is one that implements\nSerde's `Serialize` and `Deserialize` traits (or uses Serde's derive\nattribute to automatically generate implementations at compile time). This\navoids any overhead of reflection or runtime type information. In fact in\nmany situations the interaction between data structure and data format can\nbe completely optimized away by the Rust compiler, leaving Serde\nserialization to perform the same speed as a handwritten serializer for the\nspecific selection of data structure and data format.\n\n## Data formats\n\nThe following is a partial list of data formats that have been implemented\nfor Serde by the community.\n\n- [JSON], the ubiquitous JavaScript Object Notation used by many HTTP APIs.\n- [Bincode], a compact binary format\n  used for IPC within the Servo rendering engine.\n- [CBOR], a Concise Binary Object Representation designed for small message\n  size without the need for version negotiation.\n- [YAML], a self-proclaimed human-friendly configuration language that ain't\n  markup language.\n- [MessagePack], an efficient binary format that resembles a compact JSON.\n- [TOML], a minimal configuration format used by [Cargo].\n- [Pickle], a format common in the Python world.\n- [RON], a Rusty Object Notation.\n- [BSON], the data storage and network transfer format used by MongoDB.\n- [Avro], a binary format used within Apache Hadoop, with support for schema\n  definition.\n- [JSON5], a superset of JSON including some productions from ES5.\n- [Postcard], a no\\_std and embedded-systems friendly compact binary format.\n- [URL] query strings, in the x-www-form-urlencoded format.\n- [Envy], a way to deserialize environment variables into Rust structs.\n  *(deserialization only)*\n- [Envy Store], a way to deserialize [AWS Parameter Store] parameters into\n  Rust structs. *(deserialization only)*\n- [S-expressions], the textual representation of code and data used by the\n  Lisp language family.\n- [D-Bus]'s binary wire format.\n- [FlexBuffers], the schemaless cousin of Google's FlatBuffers zero-copy serialization format.\n- [DynamoDB Items], the format used by [rusoto_dynamodb] to transfer data to\n  and from DynamoDB.\n\n[JSON]: https://github.com/serde-rs/json\n[Bincode]: https://github.com/servo/bincode\n[CBOR]: https://github.com/enarx/ciborium\n[YAML]: https://github.com/dtolnay/serde-yaml\n[MessagePack]: https://github.com/3Hren/msgpack-rust\n[TOML]: https://github.com/alexcrichton/toml-rs\n[Pickle]: https://github.com/birkenfeld/serde-pickle\n[RON]: https://github.com/ron-rs/ron\n[BSON]: https://github.com/zonyitoo/bson-rs\n[Avro]: https://github.com/flavray/avro-rs\n[JSON5]: https://github.com/callum-oakley/json5-rs\n[Postcard]: https://github.com/jamesmunns/postcard\n[URL]: https://docs.rs/serde_qs\n[Envy]: https://github.com/softprops/envy\n[Envy Store]: https://github.com/softprops/envy-store\n[Cargo]: https://doc.rust-lang.org/cargo/reference/manifest.html\n[AWS Parameter Store]: https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-paramstore.html\n[S-expressions]: https://github.com/rotty/lexpr-rs\n[D-Bus]: https://docs.rs/zvariant\n[FlexBuffers]: https://github.com/google/flatbuffers/tree/master/rust/flexbuffers\n[DynamoDB Items]: https://docs.rs/serde_dynamo\n[rusoto_dynamodb]: https://docs.rs/rusoto_dynamodb"          },          filterText = "serde",          kind = 9,          label = "serde",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2934              },              start = {                character = 6,                line = 2934              }            },            newText = "serde",            replace = {              end = {                character = 13,                line = 2934              },              start = {                character = 6,                line = 2934              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "# Strum\n\nStrum is a set of macros and traits for working with\nenums and strings easier in Rust."          },          filterText = "strum_macros",          kind = 9,          label = "strum_macros",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2934              },              start = {                character = 6,                line = 2934              }            },            newText = "strum_macros",            replace = {              end = {                character = 13,                line = 2934              },              start = {                character = 6,                line = 2934              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "# The Rust Standard Library\n\nThe Rust Standard Library is the foundation of portable Rust software, a\nset of minimal and battle-tested shared abstractions for the [broader Rust\necosystem][crates.io]. It offers core types, like [`Vec<T>`] and\n[`Option<T>`], library-defined [operations on language\nprimitives](#primitives), [standard macros](#macros), [I/O] and\n[multithreading], among [many other things][other].\n\n`std` is available to all Rust crates by default. Therefore, the\nstandard library can be accessed in [`use`] statements through the path\n`std`, as in [`use std::env`].\n\n# How to read this documentation\n\nIf you already know the name of what you are looking for, the fastest way to\nfind it is to use the <a href=\"#\" onclick=\"focusSearchBar();\">search\nbar</a> at the top of the page.\n\nOtherwise, you may want to jump to one of these useful sections:\n\n* [`std::*` modules](#modules)\n* [Primitive types](#primitives)\n* [Standard macros](#macros)\n* [The Rust Prelude]\n\nIf this is your first time, the documentation for the standard library is\nwritten to be casually perused. Clicking on interesting things should\ngenerally lead you to interesting places. Still, there are important bits\nyou don't want to miss, so read on for a tour of the standard library and\nits documentation!\n\nOnce you are familiar with the contents of the standard library you may\nbegin to find the verbosity of the prose distracting. At this stage in your\ndevelopment you may want to press the `[-]` button near the top of the\npage to collapse it into a more skimmable view.\n\nWhile you are looking at that `[-]` button also notice the `source`\nlink. Rust's API documentation comes with the source code and you are\nencouraged to read it. The standard library source is generally high\nquality and a peek behind the curtains is often enlightening.\n\n# What is in the standard library documentation?\n\nFirst of all, The Rust Standard Library is divided into a number of focused\nmodules, [all listed further down this page](#modules). These modules are\nthe bedrock upon which all of Rust is forged, and they have mighty names\nlike [`std::slice`] and [`std::cmp`]. Modules' documentation typically\nincludes an overview of the module along with examples, and are a smart\nplace to start familiarizing yourself with the library.\n\nSecond, implicit methods on [primitive types] are documented here. This can\nbe a source of confusion for two reasons:\n\n1. While primitives are implemented by the compiler, the standard library\n   implements methods directly on the primitive types (and it is the only\n   library that does so), which are [documented in the section on\n   primitives](#primitives).\n2. The standard library exports many modules *with the same name as\n   primitive types*. These define additional items related to the primitive\n   type, but not the all-important methods.\n\nSo for example there is a [page for the primitive type\n`i32`](primitive::i32) that lists all the methods that can be called on\n32-bit integers (very useful), and there is a [page for the module\n`std::i32`] that documents the constant values [`MIN`] and [`MAX`] (rarely\nuseful).\n\nNote the documentation for the primitives [`str`] and [`[T]`][prim@slice] (also\ncalled 'slice'). Many method calls on [`String`] and [`Vec<T>`] are actually\ncalls to methods on [`str`] and [`[T]`][prim@slice] respectively, via [deref\ncoercions][deref-coercions].\n\nThird, the standard library defines [The Rust Prelude], a small collection\nof items - mostly traits - that are imported into every module of every\ncrate. The traits in the prelude are pervasive, making the prelude\ndocumentation a good entry point to learning about the library.\n\nAnd finally, the standard library exports a number of standard macros, and\n[lists them on this page](#macros) (technically, not all of the standard\nmacros are defined by the standard library - some are defined by the\ncompiler - but they are documented here the same). Like the prelude, the\nstandard macros are imported by default into all crates.\n\n# Contributing changes to the documentation\n\nCheck out the rust contribution guidelines [here](\nhttps://rustc-dev-guide.rust-lang.org/contributing.html#writing-documentation).\nThe source for this documentation can be found on\n[GitHub](https://github.com/rust-lang/rust).\nTo contribute changes, make sure you read the guidelines first, then submit\npull-requests for your suggested changes.\n\nContributions are appreciated! If you see a part of the docs that can be\nimproved, submit a PR, or chat with us first on [Discord][rust-discord]\n#docs.\n\n# A Tour of The Rust Standard Library\n\nThe rest of this crate documentation is dedicated to pointing out notable\nfeatures of The Rust Standard Library.\n\n## Containers and collections\n\nThe [`option`] and [`result`] modules define optional and error-handling\ntypes, [`Option<T>`] and [`Result<T, E>`]. The [`iter`] module defines\nRust's iterator trait, [`Iterator`], which works with the [`for`] loop to\naccess collections.\n\nThe standard library exposes three common ways to deal with contiguous\nregions of memory:\n\n* [`Vec<T>`] - A heap-allocated *vector* that is resizable at runtime.\n* [`[T; N]`][prim@array] - An inline *array* with a fixed size at compile time.\n* [`[T]`][prim@slice] - A dynamically sized *slice* into any other kind of contiguous\n  storage, whether heap-allocated or not.\n\nSlices can only be handled through some kind of *pointer*, and as such come\nin many flavors such as:\n\n* `&[T]` - *shared slice*\n* `&mut [T]` - *mutable slice*\n* [`Box<[T]>`][owned slice] - *owned slice*\n\n[`str`], a UTF-8 string slice, is a primitive type, and the standard library\ndefines many methods for it. Rust [`str`]s are typically accessed as\nimmutable references: `&str`. Use the owned [`String`] for building and\nmutating strings.\n\nFor converting to strings use the [`format!`] macro, and for converting from\nstrings use the [`FromStr`] trait.\n\nData may be shared by placing it in a reference-counted box or the [`Rc`]\ntype, and if further contained in a [`Cell`] or [`RefCell`], may be mutated\nas well as shared. Likewise, in a concurrent setting it is common to pair an\natomically-reference-counted box, [`Arc`], with a [`Mutex`] to get the same\neffect.\n\nThe [`collections`] module defines maps, sets, linked lists and other\ntypical collection types, including the common [`HashMap<K, V>`].\n\n## Platform abstractions and I/O\n\nBesides basic data types, the standard library is largely concerned with\nabstracting over differences in common platforms, most notably Windows and\nUnix derivatives.\n\nCommon types of I/O, including [files], [TCP], [UDP], are defined in the\n[`io`], [`fs`], and [`net`] modules.\n\nThe [`thread`] module contains Rust's threading abstractions. [`sync`]\ncontains further primitive shared memory types, including [`atomic`] and\n[`mpsc`], which contains the channel types for message passing.\n\n[I/O]: io\n[`MIN`]: i32::MIN\n[`MAX`]: i32::MAX\n[page for the module `std::i32`]: crate::i32\n[TCP]: net::TcpStream\n[The Rust Prelude]: prelude\n[UDP]: net::UdpSocket\n[`Arc`]: sync::Arc\n[owned slice]: boxed\n[`Cell`]: cell::Cell\n[`FromStr`]: str::FromStr\n[`HashMap<K, V>`]: collections::HashMap\n[`Mutex`]: sync::Mutex\n[`Option<T>`]: option::Option\n[`Rc`]: rc::Rc\n[`RefCell`]: cell::RefCell\n[`Result<T, E>`]: result::Result\n[`Vec<T>`]: vec::Vec\n[`atomic`]: sync::atomic\n[`for`]: ../book/ch03-05-control-flow.html#looping-through-a-collection-with-for\n[`str`]: prim@str\n[`mpsc`]: sync::mpsc\n[`std::cmp`]: cmp\n[`std::slice`]: mod@slice\n[`use std::env`]: env/index.html\n[`use`]: ../book/ch07-02-defining-modules-to-control-scope-and-privacy.html\n[crates.io]: https://crates.io\n[deref-coercions]: ../book/ch15-02-deref.html#implicit-deref-coercions-with-functions-and-methods\n[files]: fs::File\n[multithreading]: thread\n[other]: #what-is-in-the-standard-library-documentation\n[primitive types]: ../book/ch03-02-data-types.html\n[rust-discord]: https://discord.gg/rust-lang\n[array]: prim@array\n[slice]: prim@slice"          },          filterText = "std",          kind = 9,          label = "std",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2934              },              start = {                character = 6,                line = 2934              }            },            newText = "std",            replace = {              end = {                character = 13,                line = 2934              },              start = {                character = 6,                line = 2934              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "[![github]](https://github.com/dtolnay/semver)&ensp;[![crates-io]](https://crates.io/crates/semver)&ensp;[![docs-rs]](https://docs.rs/semver)\n\n[github]: https://img.shields.io/badge/github-8da0cb?style=for-the-badge&labelColor=555555&logo=github\n[crates-io]: https://img.shields.io/badge/crates.io-fc8d62?style=for-the-badge&labelColor=555555&logo=rust\n[docs-rs]: https://img.shields.io/badge/docs.rs-66c2a5?style=for-the-badge&labelColor=555555&logoColor=white&logo=data:image/svg+xml;base64,PHN2ZyByb2xlPSJpbWciIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyIgdmlld0JveD0iMCAwIDUxMiA1MTIiPjxwYXRoIGZpbGw9IiNmNWY1ZjUiIGQ9Ik00ODguNiAyNTAuMkwzOTIgMjE0VjEwNS41YzAtMTUtOS4zLTI4LjQtMjMuNC0zMy43bC0xMDAtMzcuNWMtOC4xLTMuMS0xNy4xLTMuMS0yNS4zIDBsLTEwMCAzNy41Yy0xNC4xIDUuMy0yMy40IDE4LjctMjMuNCAzMy43VjIxNGwtOTYuNiAzNi4yQzkuMyAyNTUuNSAwIDI2OC45IDAgMjgzLjlWMzk0YzAgMTMuNiA3LjcgMjYuMSAxOS45IDMyLjJsMTAwIDUwYzEwLjEgNS4xIDIyLjEgNS4xIDMyLjIgMGwxMDMuOS01MiAxMDMuOSA1MmMxMC4xIDUuMSAyMi4xIDUuMSAzMi4yIDBsMTAwLTUwYzEyLjItNi4xIDE5LjktMTguNiAxOS45LTMyLjJWMjgzLjljMC0xNS05LjMtMjguNC0yMy40LTMzLjd6TTM1OCAyMTQuOGwtODUgMzEuOXYtNjguMmw4NS0zN3Y3My4zek0xNTQgMTA0LjFsMTAyLTM4LjIgMTAyIDM4LjJ2LjZsLTEwMiA0MS40LTEwMi00MS40di0uNnptODQgMjkxLjFsLTg1IDQyLjV2LTc5LjFsODUtMzguOHY3NS40em0wLTExMmwtMTAyIDQxLjQtMTAyLTQxLjR2LS42bDEwMi0zOC4yIDEwMiAzOC4ydi42em0yNDAgMTEybC04NSA0Mi41di03OS4xbDg1LTM4Ljh2NzUuNHptMC0xMTJsLTEwMiA0MS40LTEwMi00MS40di0uNmwxMDItMzguMiAxMDIgMzguMnYuNnoiPjwvcGF0aD48L3N2Zz4K\n\n<br>\n\nA parser and evaluator for Cargo's flavor of Semantic Versioning.\n\nSemantic Versioning (see <https://semver.org>) is a guideline for how\nversion numbers are assigned and incremented. It is widely followed within\nthe Cargo/crates.io ecosystem for Rust.\n\n<br>\n\n# Example\n\n```rust\nuse semver::{BuildMetadata, Prerelease, Version, VersionReq};\n\nfn main() {\n    let req = VersionReq::parse(\">=1.2.3, <1.8.0\").unwrap();\n\n    // Check whether this requirement matches version 1.2.3-alpha.1 (no)\n    let version = Version {\n        major: 1,\n        minor: 2,\n        patch: 3,\n        pre: Prerelease::new(\"alpha.1\").unwrap(),\n        build: BuildMetadata::EMPTY,\n    };\n    assert!(!req.matches(&version));\n\n    // Check whether it matches 1.3.0 (yes it does)\n    let version = Version::parse(\"1.3.0\").unwrap();\n    assert!(req.matches(&version));\n}\n```\n\n<br><br>\n\n# Scope of this crate\n\nBesides Cargo, several other package ecosystems and package managers for\nother languages also use SemVer:&ensp;RubyGems/Bundler for Ruby, npm for\nJavaScript, Composer for PHP, CocoaPods for Objective-C...\n\nThe `semver` crate is specifically intended to implement Cargo's\ninterpretation of Semantic Versioning.\n\nWhere the various tools differ in their interpretation or implementation of\nthe spec, this crate follows the implementation choices made by Cargo. If\nyou are operating on version numbers from some other package ecosystem, you\nwill want to use a different semver library which is appropriate to that\necosystem.\n\nThe extent of Cargo's SemVer support is documented in the *[Specifying\nDependencies]* chapter of the Cargo reference.\n\n[Specifying Dependencies]: https://doc.rust-lang.org/cargo/reference/specifying-dependencies.html"          },          filterText = "semver",          kind = 9,          label = "semver",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2934              },              start = {                character = 6,                line = 2934              }            },            newText = "semver",            replace = {              end = {                character = 13,                line = 2934              },              start = {                character = 6,                line = 2934              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "# reqwest\n\nThe `reqwest` crate provides a convenient, higher-level HTTP\n[`Client`][client].\n\nIt handles many of the things that most people just expect an HTTP client\nto do for them.\n\n- Async and [blocking](blocking) Clients\n- Plain bodies, [JSON](#json), [urlencoded](#forms), [multipart](multipart)\n- Customizable [redirect policy](#redirect-policies)\n- HTTP [Proxies](#proxies)\n- Uses system-native [TLS](#tls)\n- Cookies\n\nThe [`reqwest::Client`][client] is asynchronous. For applications wishing\nto only make a few HTTP requests, the [`reqwest::blocking`](blocking) API\nmay be more convenient.\n\nAdditional learning resources include:\n\n- [The Rust Cookbook](https://rust-lang-nursery.github.io/rust-cookbook/web/clients.html)\n- [Reqwest Repository Examples](https://github.com/seanmonstar/reqwest/tree/master/examples)\n\n## Making a GET request\n\nFor a single request, you can use the [`get`][get] shortcut method.\n\n```rust\nlet body = reqwest::get(\"https://www.rust-lang.org\")\n    .await?\n    .text()\n    .await?;\n\nprintln!(\"body = {:?}\", body);\n```\n\n**NOTE**: If you plan to perform multiple requests, it is best to create a\n[`Client`][client] and reuse it, taking advantage of keep-alive connection\npooling.\n\n## Making POST requests (or setting request bodies)\n\nThere are several ways you can set the body of a request. The basic one is\nby using the `body()` method of a [`RequestBuilder`][builder]. This lets you set the\nexact raw bytes of what the body should be. It accepts various types,\nincluding `String` and `Vec<u8>`. If you wish to pass a custom\ntype, you can use the `reqwest::Body` constructors.\n\n```rust\nlet client = reqwest::Client::new();\nlet res = client.post(\"http://httpbin.org/post\")\n    .body(\"the exact body that is sent\")\n    .send()\n    .await?;\n```\n\n### Forms\n\nIt's very common to want to send form data in a request body. This can be\ndone with any type that can be serialized into form data.\n\nThis can be an array of tuples, or a `HashMap`, or a custom type that\nimplements [`Serialize`][serde].\n\n```rust\n// This will POST a body of `foo=bar&baz=quux`\nlet params = [(\"foo\", \"bar\"), (\"baz\", \"quux\")];\nlet client = reqwest::Client::new();\nlet res = client.post(\"http://httpbin.org/post\")\n    .form(&params)\n    .send()\n    .await?;\n```\n\n### JSON\n\nThere is also a `json` method helper on the [`RequestBuilder`][builder] that works in\na similar fashion the `form` method. It can take any value that can be\nserialized into JSON. The feature `json` is required.\n\n```rust\n// This will POST a body of `{\"lang\":\"rust\",\"body\":\"json\"}`\nlet mut map = HashMap::new();\nmap.insert(\"lang\", \"rust\");\nmap.insert(\"body\", \"json\");\n\nlet client = reqwest::Client::new();\nlet res = client.post(\"http://httpbin.org/post\")\n    .json(&map)\n    .send()\n    .await?;\n```\n\n## Redirect Policies\n\nBy default, a `Client` will automatically handle HTTP redirects, having a\nmaximum redirect chain of 10 hops. To customize this behavior, a\n[`redirect::Policy`][redirect] can be used with a `ClientBuilder`.\n\n## Cookies\n\nThe automatic storing and sending of session cookies can be enabled with\nthe [`cookie_store`][ClientBuilder::cookie_store] method on `ClientBuilder`.\n\n## Proxies\n\n**NOTE**: System proxies are enabled by default.\n\nSystem proxies look in environment variables to set HTTP or HTTPS proxies.\n\n`HTTP_PROXY` or `http_proxy` provide http proxies for http connections while\n`HTTPS_PROXY` or `https_proxy` provide HTTPS proxies for HTTPS connections.\n\nThese can be overwritten by adding a [`Proxy`](Proxy) to `ClientBuilder`\ni.e. `let proxy = reqwest::Proxy::http(\"https://secure.example\")?;`\nor disabled by calling `ClientBuilder::no_proxy()`.\n\n`socks` feature is required if you have configured socks proxy like this:\n\n```bash\nexport https_proxy=socks5://127.0.0.1:1086\n```\n\n## TLS\n\nBy default, a `Client` will make use of system-native transport layer\nsecurity to connect to HTTPS destinations. This means schannel on Windows,\nSecurity-Framework on macOS, and OpenSSL on Linux.\n\n- Additional X509 certificates can be configured on a `ClientBuilder` with the\n  [`Certificate`](Certificate) type.\n- Client certificates can be add to a `ClientBuilder` with the\n  [`Identity`][Identity] type.\n- Various parts of TLS can also be configured or even disabled on the\n  `ClientBuilder`.\n\n## Optional Features\n\nThe following are a list of [Cargo features][cargo-features] that can be\nenabled or disabled:\n\n- **default-tls** *(enabled by default)*: Provides TLS support to connect\n  over HTTPS.\n- **native-tls**: Enables TLS functionality provided by `native-tls`.\n- **native-tls-vendored**: Enables the `vendored` feature of `native-tls`.\n- **native-tls-alpn**: Enables the `alpn` feature of `native-tls`.\n- **rustls-tls**: Enables TLS functionality provided by `rustls`.\n  Equivalent to `rustls-tls-webpki-roots`.\n- **rustls-tls-manual-roots**: Enables TLS functionality provided by `rustls`,\n  without setting any root certificates. Roots have to be specified manually.\n- **rustls-tls-webpki-roots**: Enables TLS functionality provided by `rustls`,\n  while using root certificates from the `webpki-roots` crate.\n- **rustls-tls-native-roots**: Enables TLS functionality provided by `rustls`,\n  while using root certificates from the `rustls-native-certs` crate.\n- **blocking**: Provides the [blocking][] client API.\n- **cookies**: Provides cookie session support.\n- **gzip**: Provides response body gzip decompression.\n- **brotli**: Provides response body brotli decompression.\n- **deflate**: Provides response body deflate decompression.\n- **json**: Provides serialization and deserialization for JSON bodies.\n- **multipart**: Provides functionality for multipart forms.\n- **stream**: Adds support for `futures::Stream`.\n- **socks**: Provides SOCKS5 proxy support.\n- **trust-dns**: Enables a trust-dns async resolver instead of default\n  threadpool using `getaddrinfo`.\n\n\n[hyper]: http://hyper.rs\n[blocking]: ./blocking/index.html\n[client]: ./struct.Client.html\n[response]: ./struct.Response.html\n[get]: ./fn.get.html\n[builder]: ./struct.RequestBuilder.html\n[serde]: http://serde.rs\n[redirect]: crate::redirect\n[Proxy]: ./struct.Proxy.html\n[cargo-features]: https://doc.rust-lang.org/stable/cargo/reference/manifest.html#the-features-section"          },          filterText = "reqwest",          kind = 9,          label = "reqwest",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2934              },              start = {                character = 6,                line = 2934              }            },            newText = "reqwest",            replace = {              end = {                character = 13,                line = 2934              },              start = {                character = 6,                line = 2934              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "# The Rust Core Library\n\nThe Rust Core Library is the dependency-free[^free] foundation of [The\nRust Standard Library](../std/index.html). It is the portable glue\nbetween the language and its libraries, defining the intrinsic and\nprimitive building blocks of all Rust code. It links to no\nupstream libraries, no system libraries, and no libc.\n\n[^free]: Strictly speaking, there are some symbols which are needed but\n         they aren't always necessary.\n\nThe core library is *minimal*: it isn't even aware of heap allocation,\nnor does it provide concurrency or I/O. These things require\nplatform integration, and this library is platform-agnostic.\n\n# How to use the core library\n\nPlease note that all of these details are currently not considered stable.\n\nThis library is built on the assumption of a few existing symbols:\n\n* `memcpy`, `memcmp`, `memset` - These are core memory routines which are\n  often generated by LLVM. Additionally, this library can make explicit\n  calls to these functions. Their signatures are the same as found in C.\n  These functions are often provided by the system libc, but can also be\n  provided by the [compiler-builtins crate](https://crates.io/crates/compiler_builtins).\n\n* `rust_begin_panic` - This function takes four arguments, a\n  `fmt::Arguments`, a `&'static str`, and two `u32`'s. These four arguments\n  dictate the panic message, the file at which panic was invoked, and the\n  line and column inside the file. It is up to consumers of this core\n  library to define this panic function; it is only required to never\n  return. This requires a `lang` attribute named `panic_impl`.\n\n* `rust_eh_personality` - is used by the failure mechanisms of the\n   compiler. This is often mapped to GCC's personality function, but crates\n   which do not trigger a panic can be assured that this function is never\n   called. The `lang` attribute is called `eh_personality`."          },          filterText = "core",          kind = 9,          label = "core",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2934              },              start = {                character = 6,                line = 2934              }            },            newText = "core",            replace = {              end = {                character = 13,                line = 2934              },              start = {                character = 6,                line = 2934              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = '# Strum\n\n[![Build Status](https://travis-ci.org/Peternator7/strum.svg?branch=master)](https://travis-ci.org/Peternator7/strum)\n[![Latest Version](https://img.shields.io/crates/v/strum.svg)](https://crates.io/crates/strum)\n[![Rust Documentation](https://docs.rs/strum/badge.svg)](https://docs.rs/strum)\n\nStrum is a set of macros and traits for working with\nenums and strings easier in Rust.\n\nThe full version of the README can be found on [Github](https://github.com/Peternator7/strum).\n\n# Including Strum in Your Project\n\nImport strum and `strum_macros` into your project by adding the following lines to your\nCargo.toml. `strum_macros` contains the macros needed to derive all the traits in Strum.\n\n```toml\n[dependencies]\nstrum = "0.24"\nstrum_macros = "0.24"\n\n# You can also access strum_macros exports directly through strum using the "derive" feature\nstrum = { version = "0.24", features = ["derive"] }\n```'          },          filterText = "strum",          kind = 9,          label = "strum",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2934              },              start = {                character = 6,                line = 2934              }            },            newText = "strum",            replace = {              end = {                character = 13,                line = 2934              },              start = {                character = 6,                line = 2934              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "# Overview\n\n`once_cell` provides two new cell-like types, [`unsync::OnceCell`] and [`sync::OnceCell`]. A `OnceCell`\nmight store arbitrary non-`Copy` types, can be assigned to at most once and provides direct access\nto the stored contents. The core API looks *roughly* like this (and there's much more inside, read on!):\n\n```rust\nimpl<T> OnceCell<T> {\n    const fn new() -> OnceCell<T> { ... }\n    fn set(&self, value: T) -> Result<(), T> { ... }\n    fn get(&self) -> Option<&T> { ... }\n}\n```\n\nNote that, like with [`RefCell`] and [`Mutex`], the `set` method requires only a shared reference.\nBecause of the single assignment restriction `get` can return a `&T` instead of `Ref<T>`\nor `MutexGuard<T>`.\n\nThe `sync` flavor is thread-safe (that is, implements the [`Sync`] trait), while the `unsync` one is not.\n\n[`unsync::OnceCell`]: unsync/struct.OnceCell.html\n[`sync::OnceCell`]: sync/struct.OnceCell.html\n[`RefCell`]: https://doc.rust-lang.org/std/cell/struct.RefCell.html\n[`Mutex`]: https://doc.rust-lang.org/std/sync/struct.Mutex.html\n[`Sync`]: https://doc.rust-lang.org/std/marker/trait.Sync.html\n\n# Recipes\n\n`OnceCell` might be useful for a variety of patterns.\n\n## Safe Initialization of Global Data\n\n```rust\nuse std::{env, io};\n\nuse once_cell::sync::OnceCell;\n\n#[derive(Debug)]\npub struct Logger {\n    // ...\n}\nstatic INSTANCE: OnceCell<Logger> = OnceCell::new();\n\nimpl Logger {\n    pub fn global() -> &'static Logger {\n        INSTANCE.get().expect(\"logger is not initialized\")\n    }\n\n    fn from_cli(args: env::Args) -> Result<Logger, std::io::Error> {\n       // ...\n    }\n}\n\nfn main() {\n    let logger = Logger::from_cli(env::args()).unwrap();\n    INSTANCE.set(logger).unwrap();\n    // use `Logger::global()` from now on\n}\n```\n\n## Lazy Initialized Global Data\n\nThis is essentially the `lazy_static!` macro, but without a macro.\n\n```rust\nuse std::{sync::Mutex, collections::HashMap};\n\nuse once_cell::sync::OnceCell;\n\nfn global_data() -> &'static Mutex<HashMap<i32, String>> {\n    static INSTANCE: OnceCell<Mutex<HashMap<i32, String>>> = OnceCell::new();\n    INSTANCE.get_or_init(|| {\n        let mut m = HashMap::new();\n        m.insert(13, \"Spica\".to_string());\n        m.insert(74, \"Hoyten\".to_string());\n        Mutex::new(m)\n    })\n}\n```\n\nThere are also the [`sync::Lazy`] and [`unsync::Lazy`] convenience types to streamline this pattern:\n\n```rust\nuse std::{sync::Mutex, collections::HashMap};\nuse once_cell::sync::Lazy;\n\nstatic GLOBAL_DATA: Lazy<Mutex<HashMap<i32, String>>> = Lazy::new(|| {\n    let mut m = HashMap::new();\n    m.insert(13, \"Spica\".to_string());\n    m.insert(74, \"Hoyten\".to_string());\n    Mutex::new(m)\n});\n\nfn main() {\n    println!(\"{:?}\", GLOBAL_DATA.lock().unwrap());\n}\n```\n\nNote that the variable that holds `Lazy` is declared as `static`, *not*\n`const`. This is important: using `const` instead compiles, but works wrong.\n\n[`sync::Lazy`]: sync/struct.Lazy.html\n[`unsync::Lazy`]: unsync/struct.Lazy.html\n\n## General purpose lazy evaluation\n\nUnlike `lazy_static!`, `Lazy` works with local variables.\n\n```rust\nuse once_cell::unsync::Lazy;\n\nfn main() {\n    let ctx = vec![1, 2, 3];\n    let thunk = Lazy::new(|| {\n        ctx.iter().sum::<i32>()\n    });\n    assert_eq!(*thunk, 6);\n}\n```\n\nIf you need a lazy field in a struct, you probably should use `OnceCell`\ndirectly, because that will allow you to access `self` during initialization.\n\n```rust\nuse std::{fs, path::PathBuf};\n\nuse once_cell::unsync::OnceCell;\n\nstruct Ctx {\n    config_path: PathBuf,\n    config: OnceCell<String>,\n}\n\nimpl Ctx {\n    pub fn get_config(&self) -> Result<&str, std::io::Error> {\n        let cfg = self.config.get_or_try_init(|| {\n            fs::read_to_string(&self.config_path)\n        })?;\n        Ok(cfg.as_str())\n    }\n}\n```\n\n## Lazily Compiled Regex\n\nThis is a `regex!` macro which takes a string literal and returns an\n*expression* that evaluates to a `&'static Regex`:\n\n```rust\nmacro_rules! regex {\n    ($re:literal $(,)?) => {{\n        static RE: once_cell::sync::OnceCell<regex::Regex> = once_cell::sync::OnceCell::new();\n        RE.get_or_init(|| regex::Regex::new($re).unwrap())\n    }};\n}\n```\n\nThis macro can be useful to avoid the \"compile regex on every loop iteration\" problem.\n\n## Runtime `include_bytes!`\n\nThe `include_bytes` macro is useful to include test resources, but it slows\ndown test compilation a lot. An alternative is to load the resources at\nruntime:\n\n```rust\nuse std::path::Path;\n\nuse once_cell::sync::OnceCell;\n\npub struct TestResource {\n    path: &'static str,\n    cell: OnceCell<Vec<u8>>,\n}\n\nimpl TestResource {\n    pub const fn new(path: &'static str) -> TestResource {\n        TestResource { path, cell: OnceCell::new() }\n    }\n    pub fn bytes(&self) -> &[u8] {\n        self.cell.get_or_init(|| {\n            let dir = std::env::var(\"CARGO_MANIFEST_DIR\").unwrap();\n            let path = Path::new(dir.as_str()).join(self.path);\n            std::fs::read(&path).unwrap_or_else(|_err| {\n                panic!(\"failed to load test resource: {}\", path.display())\n            })\n        }).as_slice()\n    }\n}\n\nstatic TEST_IMAGE: TestResource = TestResource::new(\"test_data/lena.png\");\n\n#[test]\nfn test_sobel_filter() {\n    let rgb: &[u8] = TEST_IMAGE.bytes();\n    // ...\n}\n```\n\n## `lateinit`\n\n`LateInit` type for delayed initialization. It is reminiscent of Kotlin's\n`lateinit` keyword and allows construction of cyclic data structures:\n\n\n```rust\nuse once_cell::sync::OnceCell;\n\n#[derive(Debug)]\npub struct LateInit<T> { cell: OnceCell<T> }\n\nimpl<T> LateInit<T> {\n    pub fn init(&self, value: T) {\n        assert!(self.cell.set(value).is_ok())\n    }\n}\n\nimpl<T> Default for LateInit<T> {\n    fn default() -> Self { LateInit { cell: OnceCell::default() } }\n}\n\nimpl<T> std::ops::Deref for LateInit<T> {\n    type Target = T;\n    fn deref(&self) -> &T {\n        self.cell.get().unwrap()\n    }\n}\n\n#[derive(Default, Debug)]\nstruct A<'a> {\n    b: LateInit<&'a B<'a>>,\n}\n\n#[derive(Default, Debug)]\nstruct B<'a> {\n    a: LateInit<&'a A<'a>>\n}\n\nfn build_cycle() {\n    let a = A::default();\n    let b = B::default();\n    a.b.init(&b);\n    b.a.init(&a);\n    println!(\"{:?}\", a.b.a.b.a);\n}\n```\n\n# Comparison with std\n\n|`!Sync` types         | Access Mode            | Drawbacks                                     |\n|----------------------|------------------------|-----------------------------------------------|\n|`Cell<T>`             | `T`                    | requires `T: Copy` for `get`                  |\n|`RefCell<T>`          | `RefMut<T>` / `Ref<T>` | may panic at runtime                          |\n|`unsync::OnceCell<T>` | `&T`                   | assignable only once                          |\n\n|`Sync` types          | Access Mode            | Drawbacks                                     |\n|----------------------|------------------------|-----------------------------------------------|\n|`AtomicT`             | `T`                    | works only with certain `Copy` types          |\n|`Mutex<T>`            | `MutexGuard<T>`        | may deadlock at runtime, may block the thread |\n|`sync::OnceCell<T>`   | `&T`                   | assignable only once, may block the thread    |\n\nTechnically, calling `get_or_init` will also cause a panic or a deadlock if it recursively calls\nitself. However, because the assignment can happen only once, such cases should be more rare than\nequivalents with `RefCell` and `Mutex`.\n\n# Minimum Supported `rustc` Version\n\nThis crate's minimum supported `rustc` version is `1.36.0`.\n\nIf only the `std` feature is enabled, MSRV will be updated conservatively.\nWhen using other features, like `parking_lot`, MSRV might be updated more frequently, up to the latest stable.\nIn both cases, increasing MSRV is *not* considered a semver-breaking change.\n\n# Implementation details\n\nThe implementation is based on the [`lazy_static`](https://github.com/rust-lang-nursery/lazy-static.rs/)\nand [`lazy_cell`](https://github.com/indiv0/lazycell/) crates and [`std::sync::Once`]. In some sense,\n`once_cell` just streamlines and unifies those APIs.\n\nTo implement a sync flavor of `OnceCell`, this crates uses either a custom\nre-implementation of `std::sync::Once` or `parking_lot::Mutex`. This is\ncontrolled by the `parking_lot` feature (disabled by default). Performance\nis the same for both cases, but the `parking_lot` based `OnceCell<T>` is\nsmaller by up to 16 bytes.\n\nThis crate uses `unsafe`.\n\n[`std::sync::Once`]: https://doc.rust-lang.org/std/sync/struct.Once.html\n\n# F.A.Q.\n\n**Should I use lazy_static or once_cell?**\n\nTo the first approximation, `once_cell` is both more flexible and more convenient than `lazy_static`\nand should be preferred.\n\nUnlike `once_cell`, `lazy_static` supports spinlock-based implementation of blocking which works with\n`#![no_std]`.\n\n`lazy_static` has received significantly more real world testing, but `once_cell` is also a widely\nused crate.\n\n**Should I use the sync or unsync flavor?**\n\nBecause Rust compiler checks thread safety for you, it's impossible to accidentally use `unsync` where\n`sync` is required. So, use `unsync` in single-threaded code and `sync` in multi-threaded. It's easy\nto switch between the two if code becomes multi-threaded later.\n\nAt the moment, `unsync` has an additional benefit that reentrant initialization causes a panic, which\nmight be easier to debug than a deadlock.\n\n# Related crates\n\n* [double-checked-cell](https://github.com/niklasf/double-checked-cell)\n* [lazy-init](https://crates.io/crates/lazy-init)\n* [lazycell](https://crates.io/crates/lazycell)\n* [mitochondria](https://crates.io/crates/mitochondria)\n* [lazy_static](https://crates.io/crates/lazy_static)\n\nMost of this crate's functionality is available in `std` in nightly Rust.\nSee the [tracking issue](https://github.com/rust-lang/rust/issues/74465)."          },          filterText = "once_cell",          kind = 9,          label = "once_cell",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2934              },              start = {                character = 6,                line = 2934              }            },            newText = "once_cell",            replace = {              end = {                character = 13,                line = 2934              },              start = {                character = 6,                line = 2934              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "[![github]](https://github.com/dtolnay/thiserror)&ensp;[![crates-io]](https://crates.io/crates/thiserror)&ensp;[![docs-rs]](https://docs.rs/thiserror)\n\n[github]: https://img.shields.io/badge/github-8da0cb?style=for-the-badge&labelColor=555555&logo=github\n[crates-io]: https://img.shields.io/badge/crates.io-fc8d62?style=for-the-badge&labelColor=555555&logo=rust\n[docs-rs]: https://img.shields.io/badge/docs.rs-66c2a5?style=for-the-badge&labelColor=555555&logoColor=white&logo=data:image/svg+xml;base64,PHN2ZyByb2xlPSJpbWciIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyIgdmlld0JveD0iMCAwIDUxMiA1MTIiPjxwYXRoIGZpbGw9IiNmNWY1ZjUiIGQ9Ik00ODguNiAyNTAuMkwzOTIgMjE0VjEwNS41YzAtMTUtOS4zLTI4LjQtMjMuNC0zMy43bC0xMDAtMzcuNWMtOC4xLTMuMS0xNy4xLTMuMS0yNS4zIDBsLTEwMCAzNy41Yy0xNC4xIDUuMy0yMy40IDE4LjctMjMuNCAzMy43VjIxNGwtOTYuNiAzNi4yQzkuMyAyNTUuNSAwIDI2OC45IDAgMjgzLjlWMzk0YzAgMTMuNiA3LjcgMjYuMSAxOS45IDMyLjJsMTAwIDUwYzEwLjEgNS4xIDIyLjEgNS4xIDMyLjIgMGwxMDMuOS01MiAxMDMuOSA1MmMxMC4xIDUuMSAyMi4xIDUuMSAzMi4yIDBsMTAwLTUwYzEyLjItNi4xIDE5LjktMTguNiAxOS45LTMyLjJWMjgzLjljMC0xNS05LjMtMjguNC0yMy40LTMzLjd6TTM1OCAyMTQuOGwtODUgMzEuOXYtNjguMmw4NS0zN3Y3My4zek0xNTQgMTA0LjFsMTAyLTM4LjIgMTAyIDM4LjJ2LjZsLTEwMiA0MS40LTEwMi00MS40di0uNnptODQgMjkxLjFsLTg1IDQyLjV2LTc5LjFsODUtMzguOHY3NS40em0wLTExMmwtMTAyIDQxLjQtMTAyLTQxLjR2LS42bDEwMi0zOC4yIDEwMiAzOC4ydi42em0yNDAgMTEybC04NSA0Mi41di03OS4xbDg1LTM4Ljh2NzUuNHptMC0xMTJsLTEwMiA0MS40LTEwMi00MS40di0uNmwxMDItMzguMiAxMDIgMzguMnYuNnoiPjwvcGF0aD48L3N2Zz4K\n\n<br>\n\nThis library provides a convenient derive macro for the standard library's\n[`std::error::Error`] trait.\n\n[`std::error::Error`]: https://doc.rust-lang.org/std/error/trait.Error.html\n\n<br>\n\n# Example\n\n```rust\nuse thiserror::Error;\n\n#[derive(Error, Debug)]\npub enum DataStoreError {\n    #[error(\"data store disconnected\")]\n    Disconnect(#[from] io::Error),\n    #[error(\"the data for key `{0}` is not available\")]\n    Redaction(String),\n    #[error(\"invalid header (expected {expected:?}, found {found:?})\")]\n    InvalidHeader {\n        expected: String,\n        found: String,\n    },\n    #[error(\"unknown data store error\")]\n    Unknown,\n}\n```\n\n<br>\n\n# Details\n\n- Thiserror deliberately does not appear in your public API. You get the\n  same thing as if you had written an implementation of `std::error::Error`\n  by hand, and switching from handwritten impls to thiserror or vice versa\n  is not a breaking change.\n\n- Errors may be enums, structs with named fields, tuple structs, or unit\n  structs.\n\n- A `Display` impl is generated for your error if you provide\n  `#[error(\"...\")]` messages on the struct or each variant of your enum, as\n  shown above in the example.\n\n  The messages support a shorthand for interpolating fields from the error.\n\n    - `#[error(\"{var}\")]`&ensp;⟶&ensp;`write!(\"{}\", self.var)`\n    - `#[error(\"{0}\")]`&ensp;⟶&ensp;`write!(\"{}\", self.0)`\n    - `#[error(\"{var:?}\")]`&ensp;⟶&ensp;`write!(\"{:?}\", self.var)`\n    - `#[error(\"{0:?}\")]`&ensp;⟶&ensp;`write!(\"{:?}\", self.0)`\n\n  These shorthands can be used together with any additional format args,\n  which may be arbitrary expressions. For example:\n\n  ```rust\n  # use std::i32;\n  # use thiserror::Error;\n  #\n  #[derive(Error, Debug)]\n  pub enum Error {\n      #[error(\"invalid rdo_lookahead_frames {0} (expected < {})\", i32::MAX)]\n      InvalidLookahead(u32),\n  }\n  ```\n\n  If one of the additional expression arguments needs to refer to a field of\n  the struct or enum, then refer to named fields as `.var` and tuple fields\n  as `.0`.\n\n  ```rust\n  # use thiserror::Error;\n  #\n  # fn first_char(s: &String) -> char {\n  #     s.chars().next().unwrap()\n  # }\n  #\n  # #[derive(Debug)]\n  # struct Limits {\n  #     lo: usize,\n  #     hi: usize,\n  # }\n  #\n  #[derive(Error, Debug)]\n  pub enum Error {\n      #[error(\"first letter must be lowercase but was {:?}\", first_char(.0))]\n      WrongCase(String),\n      #[error(\"invalid index {idx}, expected at least {} and at most {}\", .limits.lo, .limits.hi)]\n      OutOfBounds { idx: usize, limits: Limits },\n  }\n  ```\n\n- A `From` impl is generated for each variant containing a `#[from]`\n  attribute.\n\n  Note that the variant must not contain any other fields beyond the source\n  error and possibly a backtrace. A backtrace is captured from within the\n  `From` impl if there is a field for it.\n\n  ```rust\n  # const IGNORE: &str = stringify! {\n  #[derive(Error, Debug)]\n  pub enum MyError {\n      Io {\n          #[from]\n          source: io::Error,\n          backtrace: Backtrace,\n      },\n  }\n  # };\n  ```\n\n- The Error trait's `source()` method is implemented to return whichever\n  field has a `#[source]` attribute or is named `source`, if any. This is\n  for identifying the underlying lower level error that caused your error.\n\n  The `#[from]` attribute always implies that the same field is `#[source]`,\n  so you don't ever need to specify both attributes.\n\n  Any error type that implements `std::error::Error` or dereferences to `dyn\n  std::error::Error` will work as a source.\n\n  ```rust\n  # use std::fmt::{self, Display};\n  # use thiserror::Error;\n  #\n  #[derive(Error, Debug)]\n  pub struct MyError {\n      msg: String,\n      #[source]  // optional if field name is `source`\n      source: anyhow::Error,\n  }\n  #\n  # impl Display for MyError {\n  #     fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {\n  #         unimplemented!()\n  #     }\n  # }\n  ```\n\n- The Error trait's `backtrace()` method is implemented to return whichever\n  field has a type named `Backtrace`, if any.\n\n  ```rust\n  # const IGNORE: &str = stringify! {\n  use std::backtrace::Backtrace;\n\n  #[derive(Error, Debug)]\n  pub struct MyError {\n      msg: String,\n      backtrace: Backtrace,  // automatically detected\n  }\n  # };\n  ```\n\n- If a field is both a source (named `source`, or has `#[source]` or\n  `#[from]` attribute) *and* is marked `#[backtrace]`, then the Error\n  trait's `backtrace()` method is forwarded to the source's backtrace.\n\n  ```rust\n  # const IGNORE: &str = stringify! {\n  #[derive(Error, Debug)]\n  pub enum MyError {\n      Io {\n          #[backtrace]\n          source: io::Error,\n      },\n  }\n  # };\n  ```\n\n- Errors may use `error(transparent)` to forward the source and Display\n  methods straight through to an underlying error without adding an\n  additional message. This would be appropriate for enums that need an\n  \"anything else\" variant.\n\n  ```\n  # use thiserror::Error;\n  #\n  #[derive(Error, Debug)]\n  pub enum MyError {\n      # /*\n      ...\n      # */\n\n      #[error(transparent)]\n      Other(#[from] anyhow::Error),  // source and Display delegate to anyhow::Error\n  }\n  ```\n\n- See also the [`anyhow`] library for a convenient single error type to use\n  in application code.\n\n  [`anyhow`]: https://github.com/dtolnay/anyhow"          },          filterText = "thiserror",          kind = 9,          label = "thiserror",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2934              },              start = {                character = 6,                line = 2934              }            },            newText = "thiserror",            replace = {              end = {                character = 13,                line = 2934              },              start = {                character = 6,                line = 2934              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "A runtime for writing reliable network applications without compromising speed.\n\nTokio is an event-driven, non-blocking I/O platform for writing asynchronous\napplications with the Rust programming language. At a high level, it\nprovides a few major components:\n\n* Tools for [working with asynchronous tasks][tasks], including\n  [synchronization primitives and channels][sync] and [timeouts, sleeps, and\n  intervals][time].\n* APIs for [performing asynchronous I/O][io], including [TCP and UDP][net] sockets,\n  [filesystem][fs] operations, and [process] and [signal] management.\n* A [runtime] for executing asynchronous code, including a task scheduler,\n  an I/O driver backed by the operating system's event queue (epoll, kqueue,\n  IOCP, etc...), and a high performance timer.\n\nGuide level documentation is found on the [website].\n\n[tasks]: #working-with-tasks\n[sync]: crate::sync\n[time]: crate::time\n[io]: #asynchronous-io\n[net]: crate::net\n[fs]: crate::fs\n[process]: crate::process\n[signal]: crate::signal\n[fs]: crate::fs\n[runtime]: crate::runtime\n[website]: https://tokio.rs/tokio/tutorial\n\n# A Tour of Tokio\n\nTokio consists of a number of modules that provide a range of functionality\nessential for implementing asynchronous applications in Rust. In this\nsection, we will take a brief tour of Tokio, summarizing the major APIs and\ntheir uses.\n\nThe easiest way to get started is to enable all features. Do this by\nenabling the `full` feature flag:\n\n```toml\ntokio = { version = \"1\", features = [\"full\"] }\n```\n\n### Authoring applications\n\nTokio is great for writing applications and most users in this case shouldn't\nworry too much about what features they should pick. If you're unsure, we suggest\ngoing with `full` to ensure that you don't run into any road blocks while you're\nbuilding your application.\n\n#### Example\n\nThis example shows the quickest way to get started with Tokio.\n\n```toml\ntokio = { version = \"1\", features = [\"full\"] }\n```\n\n### Authoring libraries\n\nAs a library author your goal should be to provide the lightest weight crate\nthat is based on Tokio. To achieve this you should ensure that you only enable\nthe features you need. This allows users to pick up your crate without having\nto enable unnecessary features.\n\n#### Example\n\nThis example shows how you may want to import features for a library that just\nneeds to `tokio::spawn` and use a `TcpStream`.\n\n```toml\ntokio = { version = \"1\", features = [\"rt\", \"net\"] }\n```\n\n## Working With Tasks\n\nAsynchronous programs in Rust are based around lightweight, non-blocking\nunits of execution called [_tasks_][tasks]. The [`tokio::task`] module provides\nimportant tools for working with tasks:\n\n* The [`spawn`] function and [`JoinHandle`] type, for scheduling a new task\n  on the Tokio runtime and awaiting the output of a spawned task, respectively,\n* Functions for [running blocking operations][blocking] in an asynchronous\n  task context.\n\nThe [`tokio::task`] module is present only when the \"rt\" feature flag\nis enabled.\n\n[tasks]: task/index.html#what-are-tasks\n[`tokio::task`]: crate::task\n[`spawn`]: crate::task::spawn()\n[`JoinHandle`]: crate::task::JoinHandle\n[blocking]: task/index.html#blocking-and-yielding\n\nThe [`tokio::sync`] module contains synchronization primitives to use when\nneeding to communicate or share data. These include:\n\n* channels ([`oneshot`], [`mpsc`], and [`watch`]), for sending values\n  between tasks,\n* a non-blocking [`Mutex`], for controlling access to a shared, mutable\n  value,\n* an asynchronous [`Barrier`] type, for multiple tasks to synchronize before\n  beginning a computation.\n\nThe `tokio::sync` module is present only when the \"sync\" feature flag is\nenabled.\n\n[`tokio::sync`]: crate::sync\n[`Mutex`]: crate::sync::Mutex\n[`Barrier`]: crate::sync::Barrier\n[`oneshot`]: crate::sync::oneshot\n[`mpsc`]: crate::sync::mpsc\n[`watch`]: crate::sync::watch\n\nThe [`tokio::time`] module provides utilities for tracking time and\nscheduling work. This includes functions for setting [timeouts][timeout] for\ntasks, [sleeping][sleep] work to run in the future, or [repeating an operation at an\ninterval][interval].\n\nIn order to use `tokio::time`, the \"time\" feature flag must be enabled.\n\n[`tokio::time`]: crate::time\n[sleep]: crate::time::sleep()\n[interval]: crate::time::interval()\n[timeout]: crate::time::timeout()\n\nFinally, Tokio provides a _runtime_ for executing asynchronous tasks. Most\napplications can use the [`#[tokio::main]`][main] macro to run their code on the\nTokio runtime. However, this macro provides only basic configuration options. As\nan alternative, the [`tokio::runtime`] module provides more powerful APIs for configuring\nand managing runtimes. You should use that module if the `#[tokio::main]` macro doesn't\nprovide the functionality you need.\n\nUsing the runtime requires the \"rt\" or \"rt-multi-thread\" feature flags, to\nenable the basic [single-threaded scheduler][rt] and the [thread-pool\nscheduler][rt-multi-thread], respectively. See the [`runtime` module\ndocumentation][rt-features] for details. In addition, the \"macros\" feature\nflag enables the `#[tokio::main]` and `#[tokio::test]` attributes.\n\n[main]: attr.main.html\n[`tokio::runtime`]: crate::runtime\n[`Builder`]: crate::runtime::Builder\n[`Runtime`]: crate::runtime::Runtime\n[rt]: runtime/index.html#current-thread-scheduler\n[rt-multi-thread]: runtime/index.html#multi-thread-scheduler\n[rt-features]: runtime/index.html#runtime-scheduler\n\n## CPU-bound tasks and blocking code\n\nTokio is able to concurrently run many tasks on a few threads by repeatedly\nswapping the currently running task on each thread. However, this kind of\nswapping can only happen at `.await` points, so code that spends a long time\nwithout reaching an `.await` will prevent other tasks from running. To\ncombat this, Tokio provides two kinds of threads: Core threads and blocking\nthreads. The core threads are where all asynchronous code runs, and Tokio\nwill by default spawn one for each CPU core. The blocking threads are\nspawned on demand, can be used to run blocking code that would otherwise\nblock other tasks from running and are kept alive when not used for a certain\namount of time which can be configured with [`thread_keep_alive`].\nSince it is not possible for Tokio to swap out blocking tasks, like it\ncan do with asynchronous code, the upper limit on the number of blocking\nthreads is very large. These limits can be configured on the [`Builder`].\n\nTo spawn a blocking task, you should use the [`spawn_blocking`] function.\n\n[`Builder`]: crate::runtime::Builder\n[`spawn_blocking`]: crate::task::spawn_blocking()\n[`thread_keep_alive`]: crate::runtime::Builder::thread_keep_alive()\n\n```rust\n#[tokio::main]\nasync fn main() {\n    // This is running on a core thread.\n\n    let blocking_task = tokio::task::spawn_blocking(|| {\n        // This is running on a blocking thread.\n        // Blocking here is ok.\n    });\n\n    // We can wait for the blocking task like this:\n    // If the blocking task panics, the unwrap below will propagate the\n    // panic.\n    blocking_task.await.unwrap();\n}\n```\n\nIf your code is CPU-bound and you wish to limit the number of threads used\nto run it, you should use a separate thread pool dedicated to CPU bound tasks.\nFor example, you could consider using the [rayon] library for CPU-bound\ntasks. It is also possible to create an extra Tokio runtime dedicated to\nCPU-bound tasks, but if you do this, you should be careful that the extra\nruntime runs _only_ CPU-bound tasks, as IO-bound tasks on that runtime\nwill behave poorly.\n\nHint: If using rayon, you can use a [`oneshot`] channel to send the result back\nto Tokio when the rayon task finishes.\n\n[rayon]: https://docs.rs/rayon\n[`oneshot`]: crate::sync::oneshot\n\n## Asynchronous IO\n\nAs well as scheduling and running tasks, Tokio provides everything you need\nto perform input and output asynchronously.\n\nThe [`tokio::io`] module provides Tokio's asynchronous core I/O primitives,\nthe [`AsyncRead`], [`AsyncWrite`], and [`AsyncBufRead`] traits. In addition,\nwhen the \"io-util\" feature flag is enabled, it also provides combinators and\nfunctions for working with these traits, forming as an asynchronous\ncounterpart to [`std::io`].\n\nTokio also includes APIs for performing various kinds of I/O and interacting\nwith the operating system asynchronously. These include:\n\n* [`tokio::net`], which contains non-blocking versions of [TCP], [UDP], and\n  [Unix Domain Sockets][UDS] (enabled by the \"net\" feature flag),\n* [`tokio::fs`], similar to [`std::fs`] but for performing filesystem I/O\n  asynchronously (enabled by the \"fs\" feature flag),\n* [`tokio::signal`], for asynchronously handling Unix and Windows OS signals\n  (enabled by the \"signal\" feature flag),\n* [`tokio::process`], for spawning and managing child processes (enabled by\n  the \"process\" feature flag).\n\n[`tokio::io`]: crate::io\n[`AsyncRead`]: crate::io::AsyncRead\n[`AsyncWrite`]: crate::io::AsyncWrite\n[`AsyncBufRead`]: crate::io::AsyncBufRead\n[`std::io`]: std::io\n[`tokio::net`]: crate::net\n[TCP]: crate::net::tcp\n[UDP]: crate::net::UdpSocket\n[UDS]: crate::net::unix\n[`tokio::fs`]: crate::fs\n[`std::fs`]: std::fs\n[`tokio::signal`]: crate::signal\n[`tokio::process`]: crate::process\n\n# Examples\n\nA simple TCP echo server:\n\n```rust\nuse tokio::net::TcpListener;\nuse tokio::io::{AsyncReadExt, AsyncWriteExt};\n\n#[tokio::main]\nasync fn main() -> Result<(), Box<dyn std::error::Error>> {\n    let listener = TcpListener::bind(\"127.0.0.1:8080\").await?;\n\n    loop {\n        let (mut socket, _) = listener.accept().await?;\n\n        tokio::spawn(async move {\n            let mut buf = [0; 1024];\n\n            // In a loop, read data from the socket and write the data back.\n            loop {\n                let n = match socket.read(&mut buf).await {\n                    // socket closed\n                    Ok(n) if n == 0 => return,\n                    Ok(n) => n,\n                    Err(e) => {\n                        eprintln!(\"failed to read from socket; err = {:?}\", e);\n                        return;\n                    }\n                };\n\n                // Write the data back\n                if let Err(e) = socket.write_all(&buf[0..n]).await {\n                    eprintln!(\"failed to write to socket; err = {:?}\", e);\n                    return;\n                }\n            }\n        });\n    }\n}\n```\n\n## Feature flags\n\nTokio uses a set of [feature flags] to reduce the amount of compiled code. It\nis possible to just enable certain features over others. By default, Tokio\ndoes not enable any features but allows one to enable a subset for their use\ncase. Below is a list of the available feature flags. You may also notice\nabove each function, struct and trait there is listed one or more feature flags\nthat are required for that item to be used. If you are new to Tokio it is\nrecommended that you use the `full` feature flag which will enable all public APIs.\nBeware though that this will pull in many extra dependencies that you may not\nneed.\n\n- `full`: Enables all features listed below except `test-util` and `tracing`.\n- `rt`: Enables `tokio::spawn`, the basic (current thread) scheduler,\n        and non-scheduler utilities.\n- `rt-multi-thread`: Enables the heavier, multi-threaded, work-stealing scheduler.\n- `io-util`: Enables the IO based `Ext` traits.\n- `io-std`: Enable `Stdout`, `Stdin` and `Stderr` types.\n- `net`: Enables `tokio::net` types such as `TcpStream`, `UnixStream` and\n         `UdpSocket`, as well as (on Unix-like systems) `AsyncFd` and (on\n         FreeBSD) `PollAio`.\n- `time`: Enables `tokio::time` types and allows the schedulers to enable\n          the built in timer.\n- `process`: Enables `tokio::process` types.\n- `macros`: Enables `#[tokio::main]` and `#[tokio::test]` macros.\n- `sync`: Enables all `tokio::sync` types.\n- `signal`: Enables all `tokio::signal` types.\n- `fs`: Enables `tokio::fs` types.\n- `test-util`: Enables testing based infrastructure for the Tokio runtime.\n\n_Note: `AsyncRead` and `AsyncWrite` traits do not require any features and are\nalways available._\n\n### Internal features\n\nThese features do not expose any new API, but influence internal\nimplementation aspects of Tokio, and can pull in additional\ndependencies.\n\n- `parking_lot`: As a potential optimization, use the _parking_lot_ crate's\nsynchronization primitives internally. MSRV may increase according to the\n_parking_lot_ release in use.\n\n### Unstable features\n\nThese feature flags enable **unstable** features. The public API may break in 1.x\nreleases. To enable these features, the `--cfg tokio_unstable` must be passed to\n`rustc` when compiling. This is easiest done using the `RUSTFLAGS` env variable:\n`RUSTFLAGS=\"--cfg tokio_unstable\"`.\n\n- `tracing`: Enables tracing events.\n\n[feature flags]: https://doc.rust-lang.org/cargo/reference/manifest.html#the-features-section"          },          filterText = "tokio",          kind = 9,          label = "tokio",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2934              },              start = {                character = 6,                line = 2934              }            },            newText = "tokio",            replace = {              end = {                character = 13,                line = 2934              },              start = {                character = 6,                line = 2934              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "This is a library to compare and sort strings (or file paths) **lexicographically**. This\nmeans that non-ASCII characters such as `á` or `ß` are treated like their closest ASCII\ncharacter: `á` is treated as `a`, `ß` is treated as `ss`, etc.\n\nLexical comparisons are case-insensitive. Alphanumeric characters are sorted after all other\ncharacters (punctuation, whitespace, special characters, emojis, ...).\n\nIt is possible to enable **natural sorting**, which also handles ASCII numbers. For example,\n`50` is less than `100` with natural sorting turned on. It's also possible to skip\ncharacters that aren't alphanumeric, so e.g. `f-5` is next to `f5`.\n\nIf different strings have the same ASCII representation (e.g. `\"Foo\"` and `\"fóò\"`), it\nfalls back to the default method from the standard library, so sorting is deterministic.\n\n<table><tr><td>\n<b>NOTE</b>: This crate doesn't attempt to be correct for every locale, but it should work\nreasonably well for a wide range of locales, while providing excellent performance.\n</td></tr></table>\n\n## Usage\n\nTo sort strings or paths, you can use the `StringSort` or `PathSort` trait:\n\n```rust\nuse lexical_sort::{StringSort, natural_lexical_cmp};\n\nlet mut strings = vec![\"ß\", \"é\", \"100\", \"hello\", \"world\", \"50\", \".\", \"B!\"];\nstrings.string_sort_unstable(natural_lexical_cmp);\n\nassert_eq!(&strings, &[\".\", \"50\", \"100\", \"B!\", \"é\", \"hello\", \"ß\", \"world\"]);\n```\n\nThere are eight comparison functions:\n\n| Function                         | lexico­graphical | natural | skips non-alphanumeric chars |\n| -------------------------------- |:---------------:|:-------:|:----------------------------:|\n| `cmp`                            |                 |         |                              |\n| `only_alnum_cmp`                 |                 |         | yes                          |\n| `lexical_cmp`                    | yes             |         |                              |\n| `lexical_only_alnum_cmp`         | yes             |         | yes                          |\n| `natural_cmp`                    |                 | yes     |                              |\n| `natural_only_alnum_cmp`         |                 | yes     | yes                          |\n| `natural_lexical_cmp`            | yes             | yes     |                              |\n| `natural_lexical_­only_alnum_cmp` | yes             | yes     | yes                          |\n\nNote that only the functions that sort lexicographically are case insensitive."          },          filterText = "lexical_sort",          kind = 9,          label = "lexical_sort",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2934              },              start = {                character = 6,                line = 2934              }            },            newText = "lexical_sort",            replace = {              end = {                character = 13,                line = 2934              },              start = {                character = 6,                line = 2934              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro cfg_accessible",          documentation = {            kind = "markdown",            value = "Keeps the item it's applied to if the passed path is accessible, and removes it otherwise."          },          filterText = "cfg_accessible",          kind = 3,          label = "cfg_accessible",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2934              },              start = {                character = 6,                line = 2934              }            },            newText = "cfg_accessible",            replace = {              end = {                character = 13,                line = 2934              },              start = {                character = 6,                line = 2934              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro test_case",          documentation = {            kind = "markdown",            value = "An implementation detail of the `#[test]` and `#[bench]` macros."          },          filterText = "test_case",          kind = 3,          label = "test_case",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2934              },              start = {                character = 6,                line = 2934              }            },            newText = "test_case",            replace = {              end = {                character = 13,                line = 2934              },              start = {                character = 6,                line = 2934              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro derive",          documentation = {            kind = "markdown",            value = "Attribute macro used to apply derive macros.\n\nSee [the reference] for more info.\n\n[the reference]: ../../../reference/attributes/derive.html"          },          filterText = "derive",          kind = 3,          label = "derive",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2934              },              start = {                character = 6,                line = 2934              }            },            newText = "derive",            replace = {              end = {                character = 13,                line = 2934              },              start = {                character = 6,                line = 2934              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro test",          documentation = {            kind = "markdown",            value = "Attribute macro applied to a function to turn it into a unit test.\n\nSee [the reference] for more info.\n\n[the reference]: ../../../reference/attributes/testing.html#the-test-attribute"          },          filterText = "test",          kind = 3,          label = "test",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2934              },              start = {                character = 6,                line = 2934              }            },            newText = "test",            replace = {              end = {                character = 13,                line = 2934              },              start = {                character = 6,                line = 2934              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro bench",          documentation = {            kind = "markdown",            value = "Attribute macro applied to a function to turn it into a benchmark test."          },          filterText = "bench",          kind = 3,          label = "bench",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2934              },              start = {                character = 6,                line = 2934              }            },            newText = "bench",            replace = {              end = {                character = 13,                line = 2934              },              start = {                character = 6,                line = 2934              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro global_allocator",          documentation = {            kind = "markdown",            value = "Attribute macro applied to a static to register it as a global allocator.\n\nSee also [`std::alloc::GlobalAlloc`](../../../std/alloc/trait.GlobalAlloc.html)."          },          filterText = "global_allocator",          kind = 3,          label = "global_allocator",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2934              },              start = {                character = 6,                line = 2934              }            },            newText = "global_allocator",            replace = {              end = {                character = 13,                line = 2934              },              start = {                character = 6,                line = 2934              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro cfg_eval",          documentation = {            kind = "markdown",            value = "Expands all `#[cfg]` and `#[cfg_attr]` attributes in the code fragment it's applied to."          },          filterText = "cfg_eval",          kind = 3,          label = "cfg_eval",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2934              },              start = {                character = 6,                line = 2934              }            },            newText = "cfg_eval",            replace = {              end = {                character = 13,                line = 2934              },              start = {                character = 6,                line = 2934              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "self::",          kind = 14,          label = "self::",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2934              },              start = {                character = 6,                line = 2934              }            },            newText = "self::",            replace = {              end = {                character = 13,                line = 2934              },              start = {                character = 6,                line = 2934              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "super::",          kind = 14,          label = "super::",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2934              },              start = {                character = 6,                line = 2934              }            },            newText = "super::",            replace = {              end = {                character = 13,                line = 2934              },              start = {                character = 6,                line = 2934              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "crate::",          kind = 14,          label = "crate::",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2934              },              start = {                character = 6,                line = 2934              }            },            newText = "crate::",            replace = {              end = {                character = 13,                line = 2934              },              start = {                character = 6,                line = 2934              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "allow",          insertTextFormat = 2,          kind = 3,          label = "allow(…)",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2934              },              start = {                character = 6,                line = 2934              }            },            newText = "allow(${0:lint})",            replace = {              end = {                character = 13,                line = 2934              },              start = {                character = 6,                line = 2934              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "cfg",          insertTextFormat = 2,          kind = 3,          label = "cfg(…)",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2934              },              start = {                character = 6,                line = 2934              }            },            newText = "cfg(${0:predicate})",            replace = {              end = {                character = 13,                line = 2934              },              start = {                character = 6,                line = 2934              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "cfg_attr",          insertTextFormat = 2,          kind = 3,          label = "cfg_attr(…)",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2934              },              start = {                character = 6,                line = 2934              }            },            newText = "cfg_attr(${1:predicate}, ${0:attr})",            replace = {              end = {                character = 13,                line = 2934              },              start = {                character = 6,                line = 2934              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "deny",          insertTextFormat = 2,          kind = 3,          label = "deny(…)",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2934              },              start = {                character = 6,                line = 2934              }            },            newText = "deny(${0:lint})",            replace = {              end = {                character = 13,                line = 2934              },              start = {                character = 6,                line = 2934              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "forbid",          insertTextFormat = 2,          kind = 3,          label = "forbid(…)",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2934              },              start = {                character = 6,                line = 2934              }            },            newText = "forbid(${0:lint})",            replace = {              end = {                character = 13,                line = 2934              },              start = {                character = 6,                line = 2934              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "warn",          insertTextFormat = 2,          kind = 3,          label = "warn(…)",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2934              },              start = {                character = 6,                line = 2934              }            },            newText = "warn(${0:lint})",            replace = {              end = {                character = 13,                line = 2934              },              start = {                character = 6,                line = 2934              }            }          }        }, {          additionalTextEdits = {},          data = {            imports = { {                full_import_path = "std::default",                imported_name = "default"              } },            position = {              position = {                character = 7,                line = 2934              },              textDocument = {                uri = "file:///home/jtcf/rustworks/factorio-lib-rs/src/prototypes/mod.rs"              }            }          },          deprecated = false,          documentation = {            kind = "markdown",            value = "The `Default` trait for types which may have meaningful default values."          },          filterText = "default",          kind = 9,          label = "default (use std::default)",          sortText = "fffffff0",          textEdit = {            insert = {              end = {                character = 7,                line = 2934              },              start = {                character = 6,                line = 2934              }            },            newText = "default",            replace = {              end = {                character = 13,                line = 2934              },              start = {                character = 6,                line = 2934              }            }          }        } }    }  }}
[ERROR][2022-06-08 11:22:39] .../vim/lsp/rpc.lua:534	"No callback found for server response id 44"
[ERROR][2022-06-08 11:22:39] .../lua/vim/lsp.lua:824	"LSP[rust_analyzer]"	"on_error"	{  code = "NO_RESULT_CALLBACK_FOUND",  err = {    id = 44,    jsonrpc = "2.0",    result = {      isIncomplete = true,      items = { {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "Utilities for formatting and printing `String`s.\n\nThis module contains the runtime support for the [`format!`] syntax extension.\nThis macro is implemented in the compiler to emit calls to this module in\norder to format arguments at runtime into strings.\n\n# Usage\n\nThe [`format!`] macro is intended to be familiar to those coming from C's\n`printf`/`fprintf` functions or Python's `str.format` function.\n\nSome examples of the [`format!`] extension are:\n\n```rust\nformat!(\"Hello\");                 // => \"Hello\"\nformat!(\"Hello, {}!\", \"world\");   // => \"Hello, world!\"\nformat!(\"The number is {}\", 1);   // => \"The number is 1\"\nformat!(\"{:?}\", (3, 4));          // => \"(3, 4)\"\nformat!(\"{value}\", value=4);      // => \"4\"\nlet people = \"Rustaceans\";\nformat!(\"Hello {people}!\");       // => \"Hello Rustaceans!\"\nformat!(\"{} {}\", 1, 2);           // => \"1 2\"\nformat!(\"{:04}\", 42);             // => \"0042\" with leading zeros\nformat!(\"{:#?}\", (100, 200));     // => \"(\n                                  //       100,\n                                  //       200,\n                                  //     )\"\n```\n\nFrom these, you can see that the first argument is a format string. It is\nrequired by the compiler for this to be a string literal; it cannot be a\nvariable passed in (in order to perform validity checking). The compiler\nwill then parse the format string and determine if the list of arguments\nprovided is suitable to pass to this format string.\n\nTo convert a single value to a string, use the [`to_string`] method. This\nwill use the [`Display`] formatting trait.\n\n## Positional parameters\n\nEach formatting argument is allowed to specify which value argument it's\nreferencing, and if omitted it is assumed to be \"the next argument\". For\nexample, the format string `{} {} {}` would take three parameters, and they\nwould be formatted in the same order as they're given. The format string\n`{2} {1} {0}`, however, would format arguments in reverse order.\n\nThings can get a little tricky once you start intermingling the two types of\npositional specifiers. The \"next argument\" specifier can be thought of as an\niterator over the argument. Each time a \"next argument\" specifier is seen,\nthe iterator advances. This leads to behavior like this:\n\n```rust\nformat!(\"{1} {} {0} {}\", 1, 2); // => \"2 1 1 2\"\n```\n\nThe internal iterator over the argument has not been advanced by the time\nthe first `{}` is seen, so it prints the first argument. Then upon reaching\nthe second `{}`, the iterator has advanced forward to the second argument.\nEssentially, parameters that explicitly name their argument do not affect\nparameters that do not name an argument in terms of positional specifiers.\n\nA format string is required to use all of its arguments, otherwise it is a\ncompile-time error. You may refer to the same argument more than once in the\nformat string.\n\n## Named parameters\n\nRust itself does not have a Python-like equivalent of named parameters to a\nfunction, but the [`format!`] macro is a syntax extension that allows it to\nleverage named parameters. Named parameters are listed at the end of the\nargument list and have the syntax:\n\n```text\nidentifier '=' expression\n```\n\nFor example, the following [`format!`] expressions all use named arguments:\n\n```rust\nformat!(\"{argument}\", argument = \"test\");   // => \"test\"\nformat!(\"{name} {}\", 1, name = 2);          // => \"2 1\"\nformat!(\"{a} {c} {b}\", a=\"a\", b='b', c=3);  // => \"a 3 b\"\n```\n\nIf a named parameter does not appear in the argument list, `format!` will\nreference a variable with that name in the current scope.\n\n```rust\nlet argument = 2 + 2;\nformat!(\"{argument}\");   // => \"4\"\n\nfn make_string(a: u32, b: &str) -> String {\n    format!(\"{b} {a}\")\n}\nmake_string(927, \"label\"); // => \"label 927\"\n```\n\nIt is not valid to put positional parameters (those without names) after\narguments that have names. Like with positional parameters, it is not\nvalid to provide named parameters that are unused by the format string.\n\n# Formatting Parameters\n\nEach argument being formatted can be transformed by a number of formatting\nparameters (corresponding to `format_spec` in [the syntax](#syntax)). These\nparameters affect the string representation of what's being formatted.\n\n## Width\n\n```rust\n// All of these print \"Hello x    !\"\nprintln!(\"Hello {:5}!\", \"x\");\nprintln!(\"Hello {:1$}!\", \"x\", 5);\nprintln!(\"Hello {1:0$}!\", 5, \"x\");\nprintln!(\"Hello {:width$}!\", \"x\", width = 5);\nlet width = 5;\nprintln!(\"Hello {:width$}!\", \"x\");\n```\n\nThis is a parameter for the \"minimum width\" that the format should take up.\nIf the value's string does not fill up this many characters, then the\npadding specified by fill/alignment will be used to take up the required\nspace (see below).\n\nThe value for the width can also be provided as a [`usize`] in the list of\nparameters by adding a postfix `$`, indicating that the second argument is\na [`usize`] specifying the width.\n\nReferring to an argument with the dollar syntax does not affect the \"next\nargument\" counter, so it's usually a good idea to refer to arguments by\nposition, or use named arguments.\n\n## Fill/Alignment\n\n```rust\nassert_eq!(format!(\"Hello {:<5}!\", \"x\"),  \"Hello x    !\");\nassert_eq!(format!(\"Hello {:-<5}!\", \"x\"), \"Hello x----!\");\nassert_eq!(format!(\"Hello {:^5}!\", \"x\"),  \"Hello   x  !\");\nassert_eq!(format!(\"Hello {:>5}!\", \"x\"),  \"Hello     x!\");\n```\n\nThe optional fill character and alignment is provided normally in conjunction with the\n[`width`](#width) parameter. It must be defined before `width`, right after the `:`.\nThis indicates that if the value being formatted is smaller than\n`width` some extra characters will be printed around it.\nFilling comes in the following variants for different alignments:\n\n* `[fill]<` - the argument is left-aligned in `width` columns\n* `[fill]^` - the argument is center-aligned in `width` columns\n* `[fill]>` - the argument is right-aligned in `width` columns\n\nThe default [fill/alignment](#fillalignment) for non-numerics is a space and\nleft-aligned. The\ndefault for numeric formatters is also a space character but with right-alignment. If\nthe `0` flag (see below) is specified for numerics, then the implicit fill character is\n`0`.\n\nNote that alignment might not be implemented by some types. In particular, it\nis not generally implemented for the `Debug` trait.  A good way to ensure\npadding is applied is to format your input, then pad this resulting string\nto obtain your output:\n\n```rust\nprintln!(\"Hello {:^15}!\", format!(\"{:?}\", Some(\"hi\"))); // => \"Hello   Some(\"hi\")   !\"\n```\n\n## Sign/`#`/`0`\n\n```rust\nassert_eq!(format!(\"Hello {:+}!\", 5), \"Hello +5!\");\nassert_eq!(format!(\"{:#x}!\", 27), \"0x1b!\");\nassert_eq!(format!(\"Hello {:05}!\", 5),  \"Hello 00005!\");\nassert_eq!(format!(\"Hello {:05}!\", -5), \"Hello -0005!\");\nassert_eq!(format!(\"{:#010x}!\", 27), \"0x0000001b!\");\n```\n\nThese are all flags altering the behavior of the formatter.\n\n* `+` - This is intended for numeric types and indicates that the sign\n        should always be printed. Positive signs are never printed by\n        default, and the negative sign is only printed by default for signed values.\n        This flag indicates that the correct sign (`+` or `-`) should always be printed.\n* `-` - Currently not used\n* `#` - This flag indicates that the \"alternate\" form of printing should\n        be used. The alternate forms are:\n    * `#?` - pretty-print the [`Debug`] formatting (adds linebreaks and indentation)\n    * `#x` - precedes the argument with a `0x`\n    * `#X` - precedes the argument with a `0x`\n    * `#b` - precedes the argument with a `0b`\n    * `#o` - precedes the argument with a `0o`\n* `0` - This is used to indicate for integer formats that the padding to `width` should\n        both be done with a `0` character as well as be sign-aware. A format\n        like `{:08}` would yield `00000001` for the integer `1`, while the\n        same format would yield `-0000001` for the integer `-1`. Notice that\n        the negative version has one fewer zero than the positive version.\n        Note that padding zeros are always placed after the sign (if any)\n        and before the digits. When used together with the `#` flag, a similar\n        rule applies: padding zeros are inserted after the prefix but before\n        the digits. The prefix is included in the total width.\n\n## Precision\n\nFor non-numeric types, this can be considered a \"maximum width\". If the resulting string is\nlonger than this width, then it is truncated down to this many characters and that truncated\nvalue is emitted with proper `fill`, `alignment` and `width` if those parameters are set.\n\nFor integral types, this is ignored.\n\nFor floating-point types, this indicates how many digits after the decimal point should be\nprinted.\n\nThere are three possible ways to specify the desired `precision`:\n\n1. An integer `.N`:\n\n   the integer `N` itself is the precision.\n\n2. An integer or name followed by dollar sign `.N$`:\n\n   use format *argument* `N` (which must be a `usize`) as the precision.\n\n3. An asterisk `.*`:\n\n   `.*` means that this `{...}` is associated with *two* format inputs rather than one: the\n   first input holds the `usize` precision, and the second holds the value to print. Note that\n   in this case, if one uses the format string `{<arg>:<spec>.*}`, then the `<arg>` part refers\n   to the *value* to print, and the `precision` must come in the input preceding `<arg>`.\n\nFor example, the following calls all print the same thing `Hello x is 0.01000`:\n\n```rust\n// Hello {arg 0 (\"x\")} is {arg 1 (0.01) with precision specified inline (5)}\nprintln!(\"Hello {0} is {1:.5}\", \"x\", 0.01);\n\n// Hello {arg 1 (\"x\")} is {arg 2 (0.01) with precision specified in arg 0 (5)}\nprintln!(\"Hello {1} is {2:.0$}\", 5, \"x\", 0.01);\n\n// Hello {arg 0 (\"x\")} is {arg 2 (0.01) with precision specified in arg 1 (5)}\nprintln!(\"Hello {0} is {2:.1$}\", \"x\", 5, 0.01);\n\n// Hello {next arg (\"x\")} is {second of next two args (0.01) with precision\n//                          specified in first of next two args (5)}\nprintln!(\"Hello {} is {:.*}\",    \"x\", 5, 0.01);\n\n// Hello {next arg (\"x\")} is {arg 2 (0.01) with precision\n//                          specified in its predecessor (5)}\nprintln!(\"Hello {} is {2:.*}\",   \"x\", 5, 0.01);\n\n// Hello {next arg (\"x\")} is {arg \"number\" (0.01) with precision specified\n//                          in arg \"prec\" (5)}\nprintln!(\"Hello {} is {number:.prec$}\", \"x\", prec = 5, number = 0.01);\n```\n\nWhile these:\n\n```rust\nprintln!(\"{}, `{name:.*}` has 3 fractional digits\", \"Hello\", 3, name=1234.56);\nprintln!(\"{}, `{name:.*}` has 3 characters\", \"Hello\", 3, name=\"1234.56\");\nprintln!(\"{}, `{name:>8.*}` has 3 right-aligned characters\", \"Hello\", 3, name=\"1234.56\");\n```\n\nprint three significantly different things:\n\n```text\nHello, `1234.560` has 3 fractional digits\nHello, `123` has 3 characters\nHello, `     123` has 3 right-aligned characters\n```\n\n## Localization\n\nIn some programming languages, the behavior of string formatting functions\ndepends on the operating system's locale setting. The format functions\nprovided by Rust's standard library do not have any concept of locale and\nwill produce the same results on all systems regardless of user\nconfiguration.\n\nFor example, the following code will always print `1.5` even if the system\nlocale uses a decimal separator other than a dot.\n\n```rust\nprintln!(\"The value is {}\", 1.5);\n```\n\n# Escaping\n\nThe literal characters `{` and `}` may be included in a string by preceding\nthem with the same character. For example, the `{` character is escaped with\n`{{` and the `}` character is escaped with `}}`.\n\n```rust\nassert_eq!(format!(\"Hello {{}}\"), \"Hello {}\");\nassert_eq!(format!(\"{{ Hello\"), \"{ Hello\");\n```\n\n# Syntax\n\nTo summarize, here you can find the full grammar of format strings.\nThe syntax for the formatting language used is drawn from other languages,\nso it should not be too alien. Arguments are formatted with Python-like\nsyntax, meaning that arguments are surrounded by `{}` instead of the C-like\n`%`. The actual grammar for the formatting syntax is:\n\n```text\nformat_string := text [ maybe_format text ] *\nmaybe_format := '{' '{' | '}' '}' | format\nformat := '{' [ argument ] [ ':' format_spec ] '}'\nargument := integer | identifier\n\nformat_spec := [[fill]align][sign]['#']['0'][width]['.' precision]type\nfill := character\nalign := '<' | '^' | '>'\nsign := '+' | '-'\nwidth := count\nprecision := count | '*'\ntype := '' | '?' | 'x?' | 'X?' | identifier\ncount := parameter | integer\nparameter := argument '$'\n```\nIn the above grammar, `text` must not contain any `'{'` or `'}'` characters.\n\n# Formatting traits\n\nWhen requesting that an argument be formatted with a particular type, you\nare actually requesting that an argument ascribes to a particular trait.\nThis allows multiple actual types to be formatted via `{:x}` (like [`i8`] as\nwell as [`isize`]). The current mapping of types to traits is:\n\n* *nothing* ⇒ [`Display`]\n* `?` ⇒ [`Debug`]\n* `x?` ⇒ [`Debug`] with lower-case hexadecimal integers\n* `X?` ⇒ [`Debug`] with upper-case hexadecimal integers\n* `o` ⇒ [`Octal`]\n* `x` ⇒ [`LowerHex`]\n* `X` ⇒ [`UpperHex`]\n* `p` ⇒ [`Pointer`]\n* `b` ⇒ [`Binary`]\n* `e` ⇒ [`LowerExp`]\n* `E` ⇒ [`UpperExp`]\n\nWhat this means is that any type of argument which implements the\n[`fmt::Binary`][`Binary`] trait can then be formatted with `{:b}`. Implementations\nare provided for these traits for a number of primitive types by the\nstandard library as well. If no format is specified (as in `{}` or `{:6}`),\nthen the format trait used is the [`Display`] trait.\n\nWhen implementing a format trait for your own type, you will have to\nimplement a method of the signature:\n\n```rust\nfn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n```\n\nYour type will be passed as `self` by-reference, and then the function\nshould emit output into the `f.buf` stream. It is up to each format trait\nimplementation to correctly adhere to the requested formatting parameters.\nThe values of these parameters will be listed in the fields of the\n[`Formatter`] struct. In order to help with this, the [`Formatter`] struct also\nprovides some helper methods.\n\nAdditionally, the return value of this function is [`fmt::Result`] which is a\ntype alias of <code>[Result]<(), [std::fmt::Error]></code>. Formatting implementations\nshould ensure that they propagate errors from the [`Formatter`] (e.g., when\ncalling [`write!`]). However, they should never return errors spuriously. That\nis, a formatting implementation must and may only return an error if the\npassed-in [`Formatter`] returns an error. This is because, contrary to what\nthe function signature might suggest, string formatting is an infallible\noperation. This function only returns a result because writing to the\nunderlying stream might fail and it must provide a way to propagate the fact\nthat an error has occurred back up the stack.\n\nAn example of implementing the formatting traits would look\nlike:\n\n```rust\nuse std::fmt;\n\n#[derive(Debug)]\nstruct Vector2D {\n    x: isize,\n    y: isize,\n}\n\nimpl fmt::Display for Vector2D {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        // The `f` value implements the `Write` trait, which is what the\n        // write! macro is expecting. Note that this formatting ignores the\n        // various flags provided to format strings.\n        write!(f, \"({}, {})\", self.x, self.y)\n    }\n}\n\n// Different traits allow different forms of output of a type. The meaning\n// of this format is to print the magnitude of a vector.\nimpl fmt::Binary for Vector2D {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        let magnitude = (self.x * self.x + self.y * self.y) as f64;\n        let magnitude = magnitude.sqrt();\n\n        // Respect the formatting flags by using the helper method\n        // `pad_integral` on the Formatter object. See the method\n        // documentation for details, and the function `pad` can be used\n        // to pad strings.\n        let decimals = f.precision().unwrap_or(3);\n        let string = format!(\"{:.*}\", decimals, magnitude);\n        f.pad_integral(true, \"\", &string)\n    }\n}\n\nfn main() {\n    let myvector = Vector2D { x: 3, y: 4 };\n\n    println!(\"{myvector}\");       // => \"(3, 4)\"\n    println!(\"{myvector:?}\");     // => \"Vector2D {x: 3, y:4}\"\n    println!(\"{myvector:10.3b}\"); // => \"     5.000\"\n}\n```\n\n### `fmt::Display` vs `fmt::Debug`\n\nThese two formatting traits have distinct purposes:\n\n- [`fmt::Display`][`Display`] implementations assert that the type can be faithfully\n  represented as a UTF-8 string at all times. It is **not** expected that\n  all types implement the [`Display`] trait.\n- [`fmt::Debug`][`Debug`] implementations should be implemented for **all** public types.\n  Output will typically represent the internal state as faithfully as possible.\n  The purpose of the [`Debug`] trait is to facilitate debugging Rust code. In\n  most cases, using `#[derive(Debug)]` is sufficient and recommended.\n\nSome examples of the output from both traits:\n\n```rust\nassert_eq!(format!(\"{} {:?}\", 3, 4), \"3 4\");\nassert_eq!(format!(\"{} {:?}\", 'a', 'b'), \"a 'b'\");\nassert_eq!(format!(\"{} {:?}\", \"foo\\n\", \"bar\\n\"), \"foo\\n \\\"bar\\\\n\\\"\");\n```\n\n# Related macros\n\nThere are a number of related macros in the [`format!`] family. The ones that\nare currently implemented are:\n\n```rust\nformat!      // described above\nwrite!       // first argument is a &mut io::Write, the destination\nwriteln!     // same as write but appends a newline\nprint!       // the format string is printed to the standard output\nprintln!     // same as print but appends a newline\neprint!      // the format string is printed to the standard error\neprintln!    // same as eprint but appends a newline\nformat_args! // described below.\n```\n\n### `write!`\n\nThis and [`writeln!`] are two macros which are used to emit the format string\nto a specified stream. This is used to prevent intermediate allocations of\nformat strings and instead directly write the output. Under the hood, this\nfunction is actually invoking the [`write_fmt`] function defined on the\n[`std::io::Write`] trait. Example usage is:\n\n```rust\nuse std::io::Write;\nlet mut w = Vec::new();\nwrite!(&mut w, \"Hello {}!\", \"world\");\n```\n\n### `print!`\n\nThis and [`println!`] emit their output to stdout. Similarly to the [`write!`]\nmacro, the goal of these macros is to avoid intermediate allocations when\nprinting output. Example usage is:\n\n```rust\nprint!(\"Hello {}!\", \"world\");\nprintln!(\"I have a newline {}\", \"character at the end\");\n```\n### `eprint!`\n\nThe [`eprint!`] and [`eprintln!`] macros are identical to\n[`print!`] and [`println!`], respectively, except they emit their\noutput to stderr.\n\n### `format_args!`\n\nThis is a curious macro used to safely pass around\nan opaque object describing the format string. This object\ndoes not require any heap allocations to create, and it only\nreferences information on the stack. Under the hood, all of\nthe related macros are implemented in terms of this. First\noff, some example usage is:\n\n```rust\nuse std::fmt;\nuse std::io::{self, Write};\n\nlet mut some_writer = io::stdout();\nwrite!(&mut some_writer, \"{}\", format_args!(\"print with a {}\", \"macro\"));\n\nfn my_fmt_fn(args: fmt::Arguments) {\n    write!(&mut io::stdout(), \"{}\", args);\n}\nmy_fmt_fn(format_args!(\", or a {} too\", \"function\"));\n```\n\nThe result of the [`format_args!`] macro is a value of type [`fmt::Arguments`].\nThis structure can then be passed to the [`write`] and [`format`] functions\ninside this module in order to process the format string.\nThe goal of this macro is to even further prevent intermediate allocations\nwhen dealing with formatting strings.\n\nFor example, a logging library could use the standard formatting syntax, but\nit would internally pass around this structure until it has been determined\nwhere output should go to.\n\n[`fmt::Result`]: Result \"fmt::Result\"\n[Result]: core::result::Result \"std::result::Result\"\n[std::fmt::Error]: Error \"fmt::Error\"\n[`write`]: write() \"fmt::write\"\n[`to_string`]: crate::string::ToString::to_string \"ToString::to_string\"\n[`write_fmt`]: ../../std/io/trait.Write.html#method.write_fmt\n[`std::io::Write`]: ../../std/io/trait.Write.html\n[`print!`]: ../../std/macro.print.html \"print!\"\n[`println!`]: ../../std/macro.println.html \"println!\"\n[`eprint!`]: ../../std/macro.eprint.html \"eprint!\"\n[`eprintln!`]: ../../std/macro.eprintln.html \"eprintln!\"\n[`fmt::Arguments`]: Arguments \"fmt::Arguments\"\n[`format`]: format() \"fmt::format\""          },          filterText = "fmt",          kind = 9,          label = "fmt",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2925              },              start = {                character = 6,                line = 2925              }            },            newText = "fmt",            replace = {              end = {                character = 13,                line = 2925              },              start = {                character = 6,                line = 2925              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "abstract_prototypes",          kind = 9,          label = "abstract_prototypes",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2925              },              start = {                character = 6,                line = 2925              }            },            newText = "abstract_prototypes",            replace = {              end = {                character = 13,                line = 2925              },              start = {                character = 6,                line = 2925              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "prototype_type",          kind = 9,          label = "prototype_type",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2925              },              start = {                character = 6,                line = 2925              }            },            newText = "prototype_type",            replace = {              end = {                character = 13,                line = 2925              },              start = {                character = 6,                line = 2925              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "additional_types",          kind = 9,          label = "additional_types",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2925              },              start = {                character = 6,                line = 2925              }            },            newText = "additional_types",            replace = {              end = {                character = 13,                line = 2925              },              start = {                character = 6,                line = 2925              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "utility",          kind = 9,          label = "utility",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2925              },              start = {                character = 6,                line = 2925              }            },            newText = "utility",            replace = {              end = {                character = 13,                line = 2925              },              start = {                character = 6,                line = 2925              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "Extra iterator adaptors, functions and macros.\n\nTo extend [`Iterator`] with methods in this crate, import\nthe [`Itertools`] trait:\n\n```rust\nuse itertools::Itertools;\n```\n\nNow, new methods like [`interleave`](Itertools::interleave)\nare available on all iterators:\n\n```rust\nuse itertools::Itertools;\n\nlet it = (1..3).interleave(vec![-1, -2]);\nitertools::assert_equal(it, vec![1, -1, 2, -2]);\n```\n\nMost iterator methods are also provided as functions (with the benefit\nthat they convert parameters using [`IntoIterator`]):\n\n```rust\nuse itertools::interleave;\n\nfor elt in interleave(&[1, 2, 3], &[2, 3, 4]) {\n    /* loop body */\n}\n```\n\n## Crate Features\n\n- `use_std`\n  - Enabled by default.\n  - Disable to compile itertools using `#![no_std]`. This disables\n    any items that depend on collections (like `group_by`, `unique`,\n    `kmerge`, `join` and many more).\n\n## Rust Version\n\nThis version of itertools requires Rust 1.32 or later."          },          filterText = "itertools",          kind = 9,          label = "itertools",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2925              },              start = {                character = 6,                line = 2925              }            },            newText = "itertools",            replace = {              end = {                character = 13,                line = 2925              },              start = {                character = 6,                line = 2925              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "# High-level bindings to Lua\n\nThe `mlua` crate provides safe high-level bindings to the [Lua programming language].\n\n# The `Lua` object\n\nThe main type exported by this library is the [`Lua`] struct. In addition to methods for\n[executing] Lua chunks or [evaluating] Lua expressions, it provides methods for creating Lua\nvalues and accessing the table of [globals].\n\n# Converting data\n\nThe [`ToLua`] and [`FromLua`] traits allow conversion from Rust types to Lua values and vice\nversa. They are implemented for many data structures found in Rust's standard library.\n\nFor more general conversions, the [`ToLuaMulti`] and [`FromLuaMulti`] traits allow converting\nbetween Rust types and *any number* of Lua values.\n\nMost code in `mlua` is generic over implementors of those traits, so in most places the normal\nRust data structures are accepted without having to write any boilerplate.\n\n# Custom Userdata\n\nThe [`UserData`] trait can be implemented by user-defined types to make them available to Lua.\nMethods and operators to be used from Lua can be added using the [`UserDataMethods`] API.\nFields are supported using the [`UserDataFields`] API.\n\n# Serde support\n\nThe [`LuaSerdeExt`] trait implemented for [`Lua`] allows conversion from Rust types to Lua values\nand vice versa using serde. Any user defined data type that implements [`serde::Serialize`] or\n[`serde::Deserialize`] can be converted.\nFor convenience, additional functionality to handle `NULL` values and arrays is provided.\n\nThe [`Value`] enum implements [`serde::Serialize`] trait to support serializing Lua values\n(including [`UserData`]) into Rust values.\n\nRequires `feature = \"serialize\"`.\n\n# Async/await support\n\nThe [`create_async_function`] allows creating non-blocking functions that returns [`Future`].\nLua code with async capabilities can be executed by [`call_async`] family of functions or polling\n[`AsyncThread`] using any runtime (eg. Tokio).\n\nRequires `feature = \"async\"`.\n\n# `Send` requirement\nBy default `mlua` is `!Send`. This can be changed by enabling `feature = \"send\"` that adds `Send` requirement\nto [`Function`]s and [`UserData`].\n\n[Lua programming language]: https://www.lua.org/\n[`Lua`]: crate::Lua\n[executing]: crate::Chunk::exec\n[evaluating]: crate::Chunk::eval\n[globals]: crate::Lua::globals\n[`ToLua`]: crate::ToLua\n[`FromLua`]: crate::FromLua\n[`ToLuaMulti`]: crate::ToLuaMulti\n[`FromLuaMulti`]: crate::FromLuaMulti\n[`Function`]: crate::Function\n[`UserData`]: crate::UserData\n[`UserDataFields`]: crate::UserDataFields\n[`UserDataMethods`]: crate::UserDataMethods\n[`LuaSerdeExt`]: crate::LuaSerdeExt\n[`Value`]: crate::Value\n[`create_async_function`]: crate::Lua::create_async_function\n[`call_async`]: crate::Function::call_async\n[`AsyncThread`]: crate::AsyncThread\n[`Future`]: std::future::Future\n[`serde::Serialize`]: https://docs.serde.rs/serde/ser/trait.Serialize.html\n[`serde::Deserialize`]: https://docs.serde.rs/serde/de/trait.Deserialize.html"          },          filterText = "mlua",          kind = 9,          label = "mlua",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2925              },              start = {                character = 6,                line = 2925              }            },            newText = "mlua",            replace = {              end = {                character = 13,                line = 2925              },              start = {                character = 6,                line = 2925              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "# The Rust core allocation and collections library\n\nThis library provides smart pointers and collections for managing\nheap-allocated values.\n\nThis library, like libcore, normally doesn’t need to be used directly\nsince its contents are re-exported in the [`std` crate](../std/index.html).\nCrates that use the `#![no_std]` attribute however will typically\nnot depend on `std`, so they’d use this crate instead.\n\n## Boxed values\n\nThe [`Box`] type is a smart pointer type. There can only be one owner of a\n[`Box`], and the owner can decide to mutate the contents, which live on the\nheap.\n\nThis type can be sent among threads efficiently as the size of a `Box` value\nis the same as that of a pointer. Tree-like data structures are often built\nwith boxes because each node often has only one owner, the parent.\n\n## Reference counted pointers\n\nThe [`Rc`] type is a non-threadsafe reference-counted pointer type intended\nfor sharing memory within a thread. An [`Rc`] pointer wraps a type, `T`, and\nonly allows access to `&T`, a shared reference.\n\nThis type is useful when inherited mutability (such as using [`Box`]) is too\nconstraining for an application, and is often paired with the [`Cell`] or\n[`RefCell`] types in order to allow mutation.\n\n## Atomically reference counted pointers\n\nThe [`Arc`] type is the threadsafe equivalent of the [`Rc`] type. It\nprovides all the same functionality of [`Rc`], except it requires that the\ncontained type `T` is shareable. Additionally, [`Arc<T>`][`Arc`] is itself\nsendable while [`Rc<T>`][`Rc`] is not.\n\nThis type allows for shared access to the contained data, and is often\npaired with synchronization primitives such as mutexes to allow mutation of\nshared resources.\n\n## Collections\n\nImplementations of the most common general purpose data structures are\ndefined in this library. They are re-exported through the\n[standard collections library](../std/collections/index.html).\n\n## Heap interfaces\n\nThe [`alloc`](alloc/index.html) module defines the low-level interface to the\ndefault global allocator. It is not compatible with the libc allocator API.\n\n[`Arc`]: sync\n[`Box`]: boxed\n[`Cell`]: core::cell\n[`Rc`]: rc\n[`RefCell`]: core::cell"          },          filterText = "alloc",          kind = 9,          label = "alloc",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2925              },              start = {                character = 6,                line = 2925              }            },            newText = "alloc",            replace = {              end = {                character = 13,                line = 2925              },              start = {                character = 6,                line = 2925              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "This crate is not intended for use outside of [factorio-lib-rs]!"          },          filterText = "factorio_lib_rs_derive",          kind = 9,          label = "factorio_lib_rs_derive",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2925              },              start = {                character = 6,                line = 2925              }            },            newText = "factorio_lib_rs_derive",            replace = {              end = {                character = 13,                line = 2925              },              start = {                character = 6,                line = 2925              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = " Compile-time string formatting.\n\n This crate provides types and macros for formatting strings at compile-time.\n\n # Rust versions\n\n There are some features that require Rust 1.46.0,\n some that require Rust 1.51.0,\n and others that require Rust nightly,\n the sections below describe the features that are available for each version.\n\n ### Rust 1.46.0\n\n These macros are the only things available in Rust 1.46.0:\n\n - [`concatcp`]:\n Concatenates `integers`, `bool`, `char`, and `&str` constants into a `&'static str` constant.\n\n - [`formatcp`]:\n [`format`]-like formatting which takes `integers`, `bool`, `char`, and `&str` constants,\n and emits a `&'static str` constant.\n\n - [`str_get`]:\n Indexes a `&'static str` constant, returning `None` when the index is out of bounds.\n\n - [`str_index`]:\n Indexes a `&'static str` constant.\n\n - [`str_repeat`]:\n Creates a `&'static str` by repeating a `&'static str` constant `times` times.\n\n - [`str_splice`]:\n Replaces a substring in a `&'static str` constant.\n\n\n ### Rust 1.51.0\n\n By enabling the \"const_generics\" feature, you can use these macros:\n\n - [`map_ascii_case`]:\n Converts a `&'static str` constant to a different casing style,\n determined by a [`Case`] argument.\n\n - [`str_replace`]:\n Replaces all the instances of a pattern in a `&'static str` constant with\n another `&'static str` constant.\n\n ### Rust 1.57.0\n\n The \"assertcp\" feature enables the [`assertcp`], [`assertcp_eq`],\n and [`assertcp_ne`] macros.\n These macros are like the standard library assert macros,\n but evaluated at compile-time,\n with the limitation that they can only have primitive types as arguments\n (just like [`concatcp`] and [`formatcp`]).\n\n ### Rust nightly\n\n By enabling the \"fmt\" feature, you can use a [`std::fmt`]-like API.\n\n This requires the nightly compiler because it uses mutable references in const fn,\n which have not been stabilized as of writing these docs.\n\n All the other features of this crate are implemented on top of the [`const_format::fmt`] API:\n\n - [`concatc`]:\n Concatenates many standard library and user defined types into a `&'static str` constant.\n\n - [`formatc`]:\n [`format`]-like macro that can format many standard library and user defined types into\n a `&'static str` constant.\n\n - [`writec`]:\n [`write`]-like macro that can format many standard library and user defined types\n into a type that implements [`WriteMarker`].\n\n The \"derive\" feature enables the [`ConstDebug`] macro,\n and the \"fmt\" feature.<br>\n [`ConstDebug`] derives the [`FormatMarker`] trait,\n and implements an inherent `const_debug_fmt` method for compile-time debug formatting.\n\n The \"assertc\" feature enables the [`assertc`], [`assertc_eq`], [`assertc_ne`] macros,\n and the \"fmt\" feature.<br>\n These macros are like the standard library assert macros, but evaluated at compile-time.\n # Examples\n\n ### Concatenation of primitive types\n\n This example works in Rust 1.46.0.\n\n ```rust\n use const_format::concatcp;\n\n const NAME: &str = \"Bob\";\n const FOO: &str = concatcp!(NAME, \", age \", 21u8,\"!\");\n\n assert_eq!(FOO, \"Bob, age 21!\");\n ```\n\n ### Formatting primitive types\n\n This example works in Rust 1.46.0.\n\n ```rust\n use const_format::formatcp;\n\n const NAME: &str = \"John\";\n\n const FOO: &str = formatcp!(\"{NAME}, age {}!\", compute_age(NAME));\n\n assert_eq!(FOO, \"John, age 24!\");\n\n # const fn compute_age(s: &str) -> usize { s.len() * 6 }\n\n ```\n\n ### Formatting custom types\n\n This example demonstrates how you can use the [`ConstDebug`] derive macro,\n and then format the type into a `&'static str` constant.\n\n This example requires Rust nightly, and the \"derive\" feature.\n\n```rust\n #![feature(const_mut_refs)]\n\n use const_format::{ConstDebug, formatc};\n\n #[derive(ConstDebug)]\n struct Message{\n     ip: [Octet; 4],\n     value: &'static str,\n }\n\n #[derive(ConstDebug)]\n struct Octet(u8);\n\n const MSG: Message = Message{\n     ip: [Octet(127), Octet(0), Octet(0), Octet(1)],\n     value: \"Hello, World!\",\n };\n\n const FOO: &str = formatc!(\"{:?}\", MSG);\n\n assert_eq!(\n     FOO,\n     \"Message { ip: [Octet(127), Octet(0), Octet(0), Octet(1)], value: \\\"Hello, World!\\\" }\"\n );\n\n ```\n\n## Formatted const assertions\n\n This example demonstrates how you can use the [`assertcp_ne`] macro to\n do compile-time inequality assertions with formatted error messages.\n\n This requires the \"assertcp\" feature,\n because using the `panic` macro at compile-time requires Rust 1.57.0.\n\n```ignore\n #![feature(const_mut_refs)]\n\n use const_format::assertcp_ne;\n\n macro_rules! check_valid_pizza{\n     ($user:expr, $topping:expr) => {\n         assertcp_ne!(\n             $topping,\n             \"pineapple\",\n             \"You can't put pineapple on pizza, {}\",\n             $user,\n         );\n     }\n }\n\n check_valid_pizza!(\"John\", \"salami\");\n check_valid_pizza!(\"Dave\", \"sausage\");\n check_valid_pizza!(\"Bob\", \"pineapple\");\n\n # fn main(){}\n ```\n\n This is the compiler output:\n\n ```text\n error[E0080]: evaluation of constant value failed\n   --> src/lib.rs:178:27\n    |\n 20 | check_valid_pizza!(\"Bob\", \"pineapple\");\n    |                           ^^^^^^^^^^^ the evaluated program panicked at '\n assertion failed: `(left != right)`\n  left: `\"pineapple\"`\n right: `\"pineapple\"`\n You can't put pineapple on pizza, Bob\n ', src/lib.rs:20:27\n\n\n ```\n\n <div id=\"macro-limitations\"></div>\n\n # Limitations\n\n All of the macros from `const_format` have these limitations:\n\n - The formatting macros that expand to\n `&'static str`s can only use constants from concrete types,\n so while a `Type::<u8>::FOO` argument would be fine,\n `Type::<T>::FOO` would not be (`T` being a type parameter).\n\n - Integer arguments must have a type inferrable from context,\n [more details in the Integer arguments section](#integer-args).\n\n - They cannot be used places that take string literals.\n So `#[doc = \"foobar\"]` cannot be replaced with `#[doc = concatcp!(\"foo\", \"bar\") ]`.\n\n <span id=\"integer-args\"></span>\n\n ### Integer arguments\n\n Integer arguments must have a type inferrable from context.\n so if you only pass an integer literal it must have a suffix.\n\n Example of what does compile:\n\n ```rust\n const N: u32 = 1;\n assert_eq!(const_format::concatcp!(N + 1, 2 + N), \"23\");\n\n assert_eq!(const_format::concatcp!(2u32, 2 + 1u8, 3u8 + 1), \"234\");\n ```\n\n Example of what does not compile:\n ```compile_fail\n assert_eq!(const_format::concatcp!(1 + 1, 2 + 1), \"23\");\n ```\n\n # Renaming crate\n\n All function-like macros from `const_format` can be used when the crate is renamed.\n\n The [`ConstDebug`] derive macro has the `#[cdeb(crate = \"foo::bar\")]` attribute to\n tell it where to find the `const_format` crate.\n\n Example of renaming the `const_format` crate in the Cargo.toml file:\n ```toml\n cfmt = {version = \"0.*\", package = \"const_format\"}\n ```\n\n # Cargo features\n\n - \"fmt\": Enables the [`std::fmt`]-like API,\n requires Rust nightly because it uses mutable references in const fn.<br>\n This feature includes the [`formatc`]/[`writec`] formatting macros.\n\n - \"derive\": implies the \"fmt\" feature,\n provides the [`ConstDebug`] derive macro to format user-defined types at compile-time.<br>\n This implicitly uses the `syn` crate, so clean compiles take a bit longer than without the feature.\n\n - \"assertc\": implies the \"fmt\" feature,\n enables the [`assertc`], [`assertc_eq`], and [`assertc_ne`] assertion macros.<br>\n This feature was previously named \"assert\",\n but it was renamed to avoid confusion with the \"assertcp\" feature.\n\n - \"assertcp\": Requires Rust 1.57.0, implies the \"const_generics\" feature.\n Enables the [`assertcp`], [`assertcp_eq`], and [`assertcp_ne`] assertion macros.\n\n - \"constant_time_as_str\": implies the \"fmt\" feature.\n An optimization that requires a few additional nightly features,\n allowing the `as_bytes_alt` methods and `slice_up_to_len_alt` methods to run\n in constant time, rather than linear time proportional to the truncated part of the slice.\n\n - \"const_generics\": Requires Rust 1.51.0.\n Enables the macros listed in the [Rust 1.51.0](#rust-1510) section.\n Also changes the the implementation of the [`concatcp`] and [`formatcp`]\n macros to use const generics.\n\n\n\n # No-std support\n\n `const_format` is unconditionally `#![no_std]`, it can be used anywhere Rust can be used.\n\n # Minimum Supported Rust Version\n\n `const_format` requires Rust 1.46.0, because it uses looping an branching in const contexts.\n\n Features that require newer versions of Rust, or the nightly compiler,\n need to be explicitly enabled with cargo features.\n\n\n [`assertc`]: ./macro.assertc.html\n\n [`assertc_eq`]: ./macro.assertc_eq.html\n\n [`assertc_ne`]: ./macro.assertc_ne.html\n\n [`assertcp`]: ./macro.assertcp.html\n\n [`assertcp_eq`]: ./macro.assertcp_eq.html\n\n [`assertcp_ne`]: ./macro.assertcp_ne.html\n\n [`concatcp`]: ./macro.concatcp.html\n\n [`formatcp`]: ./macro.formatcp.html\n\n [`format`]: https://doc.rust-lang.org/std/macro.format.html\n\n [`std::fmt`]: https://doc.rust-lang.org/std/fmt/index.html\n\n [`const_format::fmt`]: ./fmt/index.html\n\n [`concatc`]: ./macro.concatc.html\n\n [`formatc`]: ./macro.formatc.html\n\n [`writec`]: ./macro.writec.html\n\n [`write`]: https://doc.rust-lang.org/std/macro.write.html\n\n [`Formatter`]: ./fmt/struct.Formatter.html\n\n [`StrWriter`]: ./fmt/struct.StrWriter.html\n\n [`ConstDebug`]: ./derive.ConstDebug.html\n\n [`FormatMarker`]: ./marker_traits/trait.FormatMarker.html\n\n [`WriteMarker`]: ./marker_traits/trait.WriteMarker.html\n\n [`map_ascii_case`]: ./macro.map_ascii_case.html\n\n [`Case`]: ./enum.Case.html\n\n\n [`str_get`]: ./macro.str_get.html\n\n [`str_index`]: ./macro.str_index.html\n\n [`str_repeat`]: ./macro.str_repeat.html\n\n [`str_splice`]: ./macro.str_splice.html\n\n [`str_replace`]: ./macro.str_replace.html\n\n [`str::replace`]: https://doc.rust-lang.org/std/primitive.str.html#method.replace"          },          filterText = "const_format",          kind = 9,          label = "const_format",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2925              },              start = {                character = 6,                line = 2925              }            },            newText = "const_format",            replace = {              end = {                character = 13,                line = 2925              },              start = {                character = 6,                line = 2925              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = 'Ini parser for Rust\n\n```rust\nuse ini::Ini;\n\nlet mut conf = Ini::new();\nconf.with_section(Some("User"))\n    .set("name", "Raspberry树莓")\n    .set("value", "Pi");\nconf.with_section(Some("Library"))\n    .set("name", "Sun Yat-sen U")\n    .set("location", "Guangzhou=world");\nconf.write_to_file("conf.ini").unwrap();\n\nlet i = Ini::load_from_file("conf.ini").unwrap();\nfor (sec, prop) in i.iter() {\n    println!("Section: {:?}", sec);\n    for (k, v) in prop.iter() {\n        println!("{}:{}", k, v);\n    }\n}\n```'          },          filterText = "ini",          kind = 9,          label = "ini",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2925              },              start = {                character = 6,                line = 2925              }            },            newText = "ini",            replace = {              end = {                character = 13,                line = 2925              },              start = {                character = 6,                line = 2925              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "\nThis crate provides a library for parsing, compiling, and executing regular\nexpressions. Its syntax is similar to Perl-style regular expressions, but lacks\na few features like look around and backreferences. In exchange, all searches\nexecute in linear time with respect to the size of the regular expression and\nsearch text.\n\nThis crate's documentation provides some simple examples, describes\n[Unicode support](#unicode) and exhaustively lists the\n[supported syntax](#syntax).\n\nFor more specific details on the API for regular expressions, please see the\ndocumentation for the [`Regex`](struct.Regex.html) type.\n\n# Usage\n\nThis crate is [on crates.io](https://crates.io/crates/regex) and can be\nused by adding `regex` to your dependencies in your project's `Cargo.toml`.\n\n```toml\n[dependencies]\nregex = \"1\"\n```\n\n# Example: find a date\n\nGeneral use of regular expressions in this package involves compiling an\nexpression and then using it to search, split or replace text. For example,\nto confirm that some text resembles a date:\n\n```rust\nuse regex::Regex;\nlet re = Regex::new(r\"^\\d{4}-\\d{2}-\\d{2}$\").unwrap();\nassert!(re.is_match(\"2014-01-01\"));\n```\n\nNotice the use of the `^` and `$` anchors. In this crate, every expression\nis executed with an implicit `.*?` at the beginning and end, which allows\nit to match anywhere in the text. Anchors can be used to ensure that the\nfull text matches an expression.\n\nThis example also demonstrates the utility of\n[raw strings](https://doc.rust-lang.org/stable/reference/tokens.html#raw-string-literals)\nin Rust, which\nare just like regular strings except they are prefixed with an `r` and do\nnot process any escape sequences. For example, `\"\\\\d\"` is the same\nexpression as `r\"\\d\"`.\n\n# Example: Avoid compiling the same regex in a loop\n\nIt is an anti-pattern to compile the same regular expression in a loop\nsince compilation is typically expensive. (It takes anywhere from a few\nmicroseconds to a few **milliseconds** depending on the size of the\nregex.) Not only is compilation itself expensive, but this also prevents\noptimizations that reuse allocations internally to the matching engines.\n\nIn Rust, it can sometimes be a pain to pass regular expressions around if\nthey're used from inside a helper function. Instead, we recommend using the\n[`lazy_static`](https://crates.io/crates/lazy_static) crate to ensure that\nregular expressions are compiled exactly once.\n\nFor example:\n\n```rust\nuse lazy_static::lazy_static;\nuse regex::Regex;\n\nfn some_helper_function(text: &str) -> bool {\n    lazy_static! {\n        static ref RE: Regex = Regex::new(\"...\").unwrap();\n    }\n    RE.is_match(text)\n}\n\nfn main() {}\n```\n\nSpecifically, in this example, the regex will be compiled when it is used for\nthe first time. On subsequent uses, it will reuse the previous compilation.\n\n# Example: iterating over capture groups\n\nThis crate provides convenient iterators for matching an expression\nrepeatedly against a search string to find successive non-overlapping\nmatches. For example, to find all dates in a string and be able to access\nthem by their component pieces:\n\n```rust\nlet re = Regex::new(r\"(\\d{4})-(\\d{2})-(\\d{2})\").unwrap();\nlet text = \"2012-03-14, 2013-01-01 and 2014-07-05\";\nfor cap in re.captures_iter(text) {\n    println!(\"Month: {} Day: {} Year: {}\", &cap[2], &cap[3], &cap[1]);\n}\n// Output:\n// Month: 03 Day: 14 Year: 2012\n// Month: 01 Day: 01 Year: 2013\n// Month: 07 Day: 05 Year: 2014\n```\n\nNotice that the year is in the capture group indexed at `1`. This is\nbecause the *entire match* is stored in the capture group at index `0`.\n\n# Example: replacement with named capture groups\n\nBuilding on the previous example, perhaps we'd like to rearrange the date\nformats. This can be done with text replacement. But to make the code\nclearer, we can *name*  our capture groups and use those names as variables\nin our replacement text:\n\n```rust\nlet re = Regex::new(r\"(?P<y>\\d{4})-(?P<m>\\d{2})-(?P<d>\\d{2})\").unwrap();\nlet before = \"2012-03-14, 2013-01-01 and 2014-07-05\";\nlet after = re.replace_all(before, \"$m/$d/$y\");\nassert_eq!(after, \"03/14/2012, 01/01/2013 and 07/05/2014\");\n```\n\nThe `replace` methods are actually polymorphic in the replacement, which\nprovides more flexibility than is seen here. (See the documentation for\n`Regex::replace` for more details.)\n\nNote that if your regex gets complicated, you can use the `x` flag to\nenable insignificant whitespace mode, which also lets you write comments:\n\n```rust\nlet re = Regex::new(r\"(?x)\n  (?P<y>\\d{4}) # the year\n  -\n  (?P<m>\\d{2}) # the month\n  -\n  (?P<d>\\d{2}) # the day\n\").unwrap();\nlet before = \"2012-03-14, 2013-01-01 and 2014-07-05\";\nlet after = re.replace_all(before, \"$m/$d/$y\");\nassert_eq!(after, \"03/14/2012, 01/01/2013 and 07/05/2014\");\n```\n\nIf you wish to match against whitespace in this mode, you can still use `\\s`,\n`\\n`, `\\t`, etc. For escaping a single space character, you can escape it\ndirectly with `\\ `, use its hex character code `\\x20` or temporarily disable\nthe `x` flag, e.g., `(?-x: )`.\n\n# Example: match multiple regular expressions simultaneously\n\nThis demonstrates how to use a `RegexSet` to match multiple (possibly\noverlapping) regular expressions in a single scan of the search text:\n\n```rust\nuse regex::RegexSet;\n\nlet set = RegexSet::new(&[\n    r\"\\w+\",\n    r\"\\d+\",\n    r\"\\pL+\",\n    r\"foo\",\n    r\"bar\",\n    r\"barfoo\",\n    r\"foobar\",\n]).unwrap();\n\n// Iterate over and collect all of the matches.\nlet matches: Vec<_> = set.matches(\"foobar\").into_iter().collect();\nassert_eq!(matches, vec![0, 2, 3, 4, 6]);\n\n// You can also test whether a particular regex matched:\nlet matches = set.matches(\"foobar\");\nassert!(!matches.matched(5));\nassert!(matches.matched(6));\n```\n\n# Pay for what you use\n\nWith respect to searching text with a regular expression, there are three\nquestions that can be asked:\n\n1. Does the text match this expression?\n2. If so, where does it match?\n3. Where did the capturing groups match?\n\nGenerally speaking, this crate could provide a function to answer only #3,\nwhich would subsume #1 and #2 automatically. However, it can be significantly\nmore expensive to compute the location of capturing group matches, so it's best\nnot to do it if you don't need to.\n\nTherefore, only use what you need. For example, don't use `find` if you\nonly need to test if an expression matches a string. (Use `is_match`\ninstead.)\n\n# Unicode\n\nThis implementation executes regular expressions **only** on valid UTF-8\nwhile exposing match locations as byte indices into the search string. (To\nrelax this restriction, use the [`bytes`](bytes/index.html) sub-module.)\n\nOnly simple case folding is supported. Namely, when matching\ncase-insensitively, the characters are first mapped using the \"simple\" case\nfolding rules defined by Unicode.\n\nRegular expressions themselves are **only** interpreted as a sequence of\nUnicode scalar values. This means you can use Unicode characters directly\nin your expression:\n\n```rust\nlet re = Regex::new(r\"(?i)Δ+\").unwrap();\nlet mat = re.find(\"ΔδΔ\").unwrap();\nassert_eq!((mat.start(), mat.end()), (0, 6));\n```\n\nMost features of the regular expressions in this crate are Unicode aware. Here\nare some examples:\n\n* `.` will match any valid UTF-8 encoded Unicode scalar value except for `\\n`.\n  (To also match `\\n`, enable the `s` flag, e.g., `(?s:.)`.)\n* `\\w`, `\\d` and `\\s` are Unicode aware. For example, `\\s` will match all forms\n  of whitespace categorized by Unicode.\n* `\\b` matches a Unicode word boundary.\n* Negated character classes like `[^a]` match all Unicode scalar values except\n  for `a`.\n* `^` and `$` are **not** Unicode aware in multi-line mode. Namely, they only\n  recognize `\\n` and not any of the other forms of line terminators defined\n  by Unicode.\n\nUnicode general categories, scripts, script extensions, ages and a smattering\nof boolean properties are available as character classes. For example, you can\nmatch a sequence of numerals, Greek or Cherokee letters:\n\n```rust\nlet re = Regex::new(r\"[\\pN\\p{Greek}\\p{Cherokee}]+\").unwrap();\nlet mat = re.find(\"abcΔᎠβⅠᏴγδⅡxyz\").unwrap();\nassert_eq!((mat.start(), mat.end()), (3, 23));\n```\n\nFor a more detailed breakdown of Unicode support with respect to\n[UTS#18](https://unicode.org/reports/tr18/),\nplease see the\n[UNICODE](https://github.com/rust-lang/regex/blob/master/UNICODE.md)\ndocument in the root of the regex repository.\n\n# Opt out of Unicode support\n\nThe `bytes` sub-module provides a `Regex` type that can be used to match\non `&[u8]`. By default, text is interpreted as UTF-8 just like it is with\nthe main `Regex` type. However, this behavior can be disabled by turning\noff the `u` flag, even if doing so could result in matching invalid UTF-8.\nFor example, when the `u` flag is disabled, `.` will match any byte instead\nof any Unicode scalar value.\n\nDisabling the `u` flag is also possible with the standard `&str`-based `Regex`\ntype, but it is only allowed where the UTF-8 invariant is maintained. For\nexample, `(?-u:\\w)` is an ASCII-only `\\w` character class and is legal in an\n`&str`-based `Regex`, but `(?-u:\\xFF)` will attempt to match the raw byte\n`\\xFF`, which is invalid UTF-8 and therefore is illegal in `&str`-based\nregexes.\n\nFinally, since Unicode support requires bundling large Unicode data\ntables, this crate exposes knobs to disable the compilation of those\ndata tables, which can be useful for shrinking binary size and reducing\ncompilation times. For details on how to do that, see the section on [crate\nfeatures](#crate-features).\n\n# Syntax\n\nThe syntax supported in this crate is documented below.\n\nNote that the regular expression parser and abstract syntax are exposed in\na separate crate, [`regex-syntax`](https://docs.rs/regex-syntax).\n\n## Matching one character\n\n<pre class=\"rust\">\n.             any character except new line (includes new line with s flag)\n\\d            digit (\\p{Nd})\n\\D            not digit\n\\pN           One-letter name Unicode character class\n\\p{Greek}     Unicode character class (general category or script)\n\\PN           Negated one-letter name Unicode character class\n\\P{Greek}     negated Unicode character class (general category or script)\n</pre>\n\n### Character classes\n\n<pre class=\"rust\">\n[xyz]         A character class matching either x, y or z (union).\n[^xyz]        A character class matching any character except x, y and z.\n[a-z]         A character class matching any character in range a-z.\n[[:alpha:]]   ASCII character class ([A-Za-z])\n[[:^alpha:]]  Negated ASCII character class ([^A-Za-z])\n[x[^xyz]]     Nested/grouping character class (matching any character except y and z)\n[a-y&&xyz]    Intersection (matching x or y)\n[0-9&&[^4]]   Subtraction using intersection and negation (matching 0-9 except 4)\n[0-9--4]      Direct subtraction (matching 0-9 except 4)\n[a-g~~b-h]    Symmetric difference (matching `a` and `h` only)\n[\\[\\]]        Escaping in character classes (matching [ or ])\n</pre>\n\nAny named character class may appear inside a bracketed `[...]` character\nclass. For example, `[\\p{Greek}[:digit:]]` matches any Greek or ASCII\ndigit. `[\\p{Greek}&&\\pL]` matches Greek letters.\n\nPrecedence in character classes, from most binding to least:\n\n1. Ranges: `a-cd` == `[a-c]d`\n2. Union: `ab&&bc` == `[ab]&&[bc]`\n3. Intersection: `^a-z&&b` == `^[a-z&&b]`\n4. Negation\n\n## Composites\n\n<pre class=\"rust\">\nxy    concatenation (x followed by y)\nx|y   alternation (x or y, prefer x)\n</pre>\n\n## Repetitions\n\n<pre class=\"rust\">\nx*        zero or more of x (greedy)\nx+        one or more of x (greedy)\nx?        zero or one of x (greedy)\nx*?       zero or more of x (ungreedy/lazy)\nx+?       one or more of x (ungreedy/lazy)\nx??       zero or one of x (ungreedy/lazy)\nx{n,m}    at least n x and at most m x (greedy)\nx{n,}     at least n x (greedy)\nx{n}      exactly n x\nx{n,m}?   at least n x and at most m x (ungreedy/lazy)\nx{n,}?    at least n x (ungreedy/lazy)\nx{n}?     exactly n x\n</pre>\n\n## Empty matches\n\n<pre class=\"rust\">\n^     the beginning of text (or start-of-line with multi-line mode)\n$     the end of text (or end-of-line with multi-line mode)\n\\A    only the beginning of text (even with multi-line mode enabled)\n\\z    only the end of text (even with multi-line mode enabled)\n\\b    a Unicode word boundary (\\w on one side and \\W, \\A, or \\z on other)\n\\B    not a Unicode word boundary\n</pre>\n\n## Grouping and flags\n\n<pre class=\"rust\">\n(exp)          numbered capture group (indexed by opening parenthesis)\n(?P&lt;name&gt;exp)  named (also numbered) capture group (allowed chars: [_0-9a-zA-Z.\\[\\]])\n(?:exp)        non-capturing group\n(?flags)       set flags within current group\n(?flags:exp)   set flags for exp (non-capturing)\n</pre>\n\nFlags are each a single character. For example, `(?x)` sets the flag `x`\nand `(?-x)` clears the flag `x`. Multiple flags can be set or cleared at\nthe same time: `(?xy)` sets both the `x` and `y` flags and `(?x-y)` sets\nthe `x` flag and clears the `y` flag.\n\nAll flags are by default disabled unless stated otherwise. They are:\n\n<pre class=\"rust\">\ni     case-insensitive: letters match both upper and lower case\nm     multi-line mode: ^ and $ match begin/end of line\ns     allow . to match \\n\nU     swap the meaning of x* and x*?\nu     Unicode support (enabled by default)\nx     ignore whitespace and allow line comments (starting with `#`)\n</pre>\n\nFlags can be toggled within a pattern. Here's an example that matches\ncase-insensitively for the first part but case-sensitively for the second part:\n\n```rust\nlet re = Regex::new(r\"(?i)a+(?-i)b+\").unwrap();\nlet cap = re.captures(\"AaAaAbbBBBb\").unwrap();\nassert_eq!(&cap[0], \"AaAaAbb\");\n```\n\nNotice that the `a+` matches either `a` or `A`, but the `b+` only matches\n`b`.\n\nMulti-line mode means `^` and `$` no longer match just at the beginning/end of\nthe input, but at the beginning/end of lines:\n\n```rust\nlet re = Regex::new(r\"(?m)^line \\d+\").unwrap();\nlet m = re.find(\"line one\\nline 2\\n\").unwrap();\nassert_eq!(m.as_str(), \"line 2\");\n```\n\nNote that `^` matches after new lines, even at the end of input:\n\n```rust\nlet re = Regex::new(r\"(?m)^\").unwrap();\nlet m = re.find_iter(\"test\\n\").last().unwrap();\nassert_eq!((m.start(), m.end()), (5, 5));\n```\n\nHere is an example that uses an ASCII word boundary instead of a Unicode\nword boundary:\n\n```rust\nlet re = Regex::new(r\"(?-u:\\b).+(?-u:\\b)\").unwrap();\nlet cap = re.captures(\"$$abc$$\").unwrap();\nassert_eq!(&cap[0], \"abc\");\n```\n\n## Escape sequences\n\n<pre class=\"rust\">\n\\*          literal *, works for any punctuation character: \\.+*?()|[]{}^$\n\\a          bell (\\x07)\n\\f          form feed (\\x0C)\n\\t          horizontal tab\n\\n          new line\n\\r          carriage return\n\\v          vertical tab (\\x0B)\n\\123        octal character code (up to three digits) (when enabled)\n\\x7F        hex character code (exactly two digits)\n\\x{10FFFF}  any hex character code corresponding to a Unicode code point\n\\u007F      hex character code (exactly four digits)\n\\u{7F}      any hex character code corresponding to a Unicode code point\n\\U0000007F  hex character code (exactly eight digits)\n\\U{7F}      any hex character code corresponding to a Unicode code point\n</pre>\n\n## Perl character classes (Unicode friendly)\n\nThese classes are based on the definitions provided in\n[UTS#18](https://www.unicode.org/reports/tr18/#Compatibility_Properties):\n\n<pre class=\"rust\">\n\\d     digit (\\p{Nd})\n\\D     not digit\n\\s     whitespace (\\p{White_Space})\n\\S     not whitespace\n\\w     word character (\\p{Alphabetic} + \\p{M} + \\d + \\p{Pc} + \\p{Join_Control})\n\\W     not word character\n</pre>\n\n## ASCII character classes\n\n<pre class=\"rust\">\n[[:alnum:]]    alphanumeric ([0-9A-Za-z])\n[[:alpha:]]    alphabetic ([A-Za-z])\n[[:ascii:]]    ASCII ([\\x00-\\x7F])\n[[:blank:]]    blank ([\\t ])\n[[:cntrl:]]    control ([\\x00-\\x1F\\x7F])\n[[:digit:]]    digits ([0-9])\n[[:graph:]]    graphical ([!-~])\n[[:lower:]]    lower case ([a-z])\n[[:print:]]    printable ([ -~])\n[[:punct:]]    punctuation ([!-/:-@\\[-`{-~])\n[[:space:]]    whitespace ([\\t\\n\\v\\f\\r ])\n[[:upper:]]    upper case ([A-Z])\n[[:word:]]     word characters ([0-9A-Za-z_])\n[[:xdigit:]]   hex digit ([0-9A-Fa-f])\n</pre>\n\n# Crate features\n\nBy default, this crate tries pretty hard to make regex matching both as fast\nas possible and as correct as it can be, within reason. This means that there\nis a lot of code dedicated to performance, the handling of Unicode data and the\nUnicode data itself. Overall, this leads to more dependencies, larger binaries\nand longer compile times.  This trade off may not be appropriate in all cases,\nand indeed, even when all Unicode and performance features are disabled, one\nis still left with a perfectly serviceable regex engine that will work well\nin many cases.\n\nThis crate exposes a number of features for controlling that trade off. Some\nof these features are strictly performance oriented, such that disabling them\nwon't result in a loss of functionality, but may result in worse performance.\nOther features, such as the ones controlling the presence or absence of Unicode\ndata, can result in a loss of functionality. For example, if one disables the\n`unicode-case` feature (described below), then compiling the regex `(?i)a`\nwill fail since Unicode case insensitivity is enabled by default. Instead,\ncallers must use `(?i-u)a` instead to disable Unicode case folding. Stated\ndifferently, enabling or disabling any of the features below can only add or\nsubtract from the total set of valid regular expressions. Enabling or disabling\na feature will never modify the match semantics of a regular expression.\n\nAll features below are enabled by default.\n\n### Ecosystem features\n\n* **std** -\n  When enabled, this will cause `regex` to use the standard library. Currently,\n  disabling this feature will always result in a compilation error. It is\n  intended to add `alloc`-only support to regex in the future.\n\n### Performance features\n\n* **perf** -\n  Enables all performance related features. This feature is enabled by default\n  and will always cover all features that improve performance, even if more\n  are added in the future.\n* **perf-dfa** -\n  Enables the use of a lazy DFA for matching. The lazy DFA is used to compile\n  portions of a regex to a very fast DFA on an as-needed basis. This can\n  result in substantial speedups, usually by an order of magnitude on large\n  haystacks. The lazy DFA does not bring in any new dependencies, but it can\n  make compile times longer.\n* **perf-inline** -\n  Enables the use of aggressive inlining inside match routines. This reduces\n  the overhead of each match. The aggressive inlining, however, increases\n  compile times and binary size.\n* **perf-literal** -\n  Enables the use of literal optimizations for speeding up matches. In some\n  cases, literal optimizations can result in speedups of _several_ orders of\n  magnitude. Disabling this drops the `aho-corasick` and `memchr` dependencies.\n* **perf-cache** -\n  This feature used to enable a faster internal cache at the cost of using\n  additional dependencies, but this is no longer an option. A fast internal\n  cache is now used unconditionally with no additional dependencies. This may\n  change in the future.\n\n### Unicode features\n\n* **unicode** -\n  Enables all Unicode features. This feature is enabled by default, and will\n  always cover all Unicode features, even if more are added in the future.\n* **unicode-age** -\n  Provide the data for the\n  [Unicode `Age` property](https://www.unicode.org/reports/tr44/tr44-24.html#Character_Age).\n  This makes it possible to use classes like `\\p{Age:6.0}` to refer to all\n  codepoints first introduced in Unicode 6.0\n* **unicode-bool** -\n  Provide the data for numerous Unicode boolean properties. The full list\n  is not included here, but contains properties like `Alphabetic`, `Emoji`,\n  `Lowercase`, `Math`, `Uppercase` and `White_Space`.\n* **unicode-case** -\n  Provide the data for case insensitive matching using\n  [Unicode's \"simple loose matches\" specification](https://www.unicode.org/reports/tr18/#Simple_Loose_Matches).\n* **unicode-gencat** -\n  Provide the data for\n  [Unicode general categories](https://www.unicode.org/reports/tr44/tr44-24.html#General_Category_Values).\n  This includes, but is not limited to, `Decimal_Number`, `Letter`,\n  `Math_Symbol`, `Number` and `Punctuation`.\n* **unicode-perl** -\n  Provide the data for supporting the Unicode-aware Perl character classes,\n  corresponding to `\\w`, `\\s` and `\\d`. This is also necessary for using\n  Unicode-aware word boundary assertions. Note that if this feature is\n  disabled, the `\\s` and `\\d` character classes are still available if the\n  `unicode-bool` and `unicode-gencat` features are enabled, respectively.\n* **unicode-script** -\n  Provide the data for\n  [Unicode scripts and script extensions](https://www.unicode.org/reports/tr24/).\n  This includes, but is not limited to, `Arabic`, `Cyrillic`, `Hebrew`,\n  `Latin` and `Thai`.\n* **unicode-segment** -\n  Provide the data necessary to provide the properties used to implement the\n  [Unicode text segmentation algorithms](https://www.unicode.org/reports/tr29/).\n  This enables using classes like `\\p{gcb=Extend}`, `\\p{wb=Katakana}` and\n  `\\p{sb=ATerm}`.\n\n\n# Untrusted input\n\nThis crate can handle both untrusted regular expressions and untrusted\nsearch text.\n\nUntrusted regular expressions are handled by capping the size of a compiled\nregular expression.\n(See [`RegexBuilder::size_limit`](struct.RegexBuilder.html#method.size_limit).)\nWithout this, it would be trivial for an attacker to exhaust your system's\nmemory with expressions like `a{100}{100}{100}`.\n\nUntrusted search text is allowed because the matching engine(s) in this\ncrate have time complexity `O(mn)` (with `m ~ regex` and `n ~ search\ntext`), which means there's no way to cause exponential blow-up like with\nsome other regular expression engines. (We pay for this by disallowing\nfeatures like arbitrary look-ahead and backreferences.)\n\nWhen a DFA is used, pathological cases with exponential state blow-up are\navoided by constructing the DFA lazily or in an \"online\" manner. Therefore,\nat most one new state can be created for each byte of input. This satisfies\nour time complexity guarantees, but can lead to memory growth\nproportional to the size of the input. As a stopgap, the DFA is only\nallowed to store a fixed number of states. When the limit is reached, its\nstates are wiped and continues on, possibly duplicating previous work. If\nthe limit is reached too frequently, it gives up and hands control off to\nanother matching engine with fixed memory requirements.\n(The DFA size limit can also be tweaked. See\n[`RegexBuilder::dfa_size_limit`](struct.RegexBuilder.html#method.dfa_size_limit).)"          },          filterText = "regex",          kind = 9,          label = "regex",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2925              },              start = {                character = 6,                line = 2925              }            },            newText = "regex",            replace = {              end = {                character = 13,                line = 2925              },              start = {                character = 6,                line = 2925              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "# Serde\n\nSerde is a framework for ***ser***ializing and ***de***serializing Rust data\nstructures efficiently and generically.\n\nThe Serde ecosystem consists of data structures that know how to serialize\nand deserialize themselves along with data formats that know how to\nserialize and deserialize other things. Serde provides the layer by which\nthese two groups interact with each other, allowing any supported data\nstructure to be serialized and deserialized using any supported data format.\n\nSee the Serde website <https://serde.rs/> for additional documentation and\nusage examples.\n\n## Design\n\nWhere many other languages rely on runtime reflection for serializing data,\nSerde is instead built on Rust's powerful trait system. A data structure\nthat knows how to serialize and deserialize itself is one that implements\nSerde's `Serialize` and `Deserialize` traits (or uses Serde's derive\nattribute to automatically generate implementations at compile time). This\navoids any overhead of reflection or runtime type information. In fact in\nmany situations the interaction between data structure and data format can\nbe completely optimized away by the Rust compiler, leaving Serde\nserialization to perform the same speed as a handwritten serializer for the\nspecific selection of data structure and data format.\n\n## Data formats\n\nThe following is a partial list of data formats that have been implemented\nfor Serde by the community.\n\n- [JSON], the ubiquitous JavaScript Object Notation used by many HTTP APIs.\n- [Bincode], a compact binary format\n  used for IPC within the Servo rendering engine.\n- [CBOR], a Concise Binary Object Representation designed for small message\n  size without the need for version negotiation.\n- [YAML], a self-proclaimed human-friendly configuration language that ain't\n  markup language.\n- [MessagePack], an efficient binary format that resembles a compact JSON.\n- [TOML], a minimal configuration format used by [Cargo].\n- [Pickle], a format common in the Python world.\n- [RON], a Rusty Object Notation.\n- [BSON], the data storage and network transfer format used by MongoDB.\n- [Avro], a binary format used within Apache Hadoop, with support for schema\n  definition.\n- [JSON5], a superset of JSON including some productions from ES5.\n- [Postcard], a no\\_std and embedded-systems friendly compact binary format.\n- [URL] query strings, in the x-www-form-urlencoded format.\n- [Envy], a way to deserialize environment variables into Rust structs.\n  *(deserialization only)*\n- [Envy Store], a way to deserialize [AWS Parameter Store] parameters into\n  Rust structs. *(deserialization only)*\n- [S-expressions], the textual representation of code and data used by the\n  Lisp language family.\n- [D-Bus]'s binary wire format.\n- [FlexBuffers], the schemaless cousin of Google's FlatBuffers zero-copy serialization format.\n- [DynamoDB Items], the format used by [rusoto_dynamodb] to transfer data to\n  and from DynamoDB.\n\n[JSON]: https://github.com/serde-rs/json\n[Bincode]: https://github.com/servo/bincode\n[CBOR]: https://github.com/enarx/ciborium\n[YAML]: https://github.com/dtolnay/serde-yaml\n[MessagePack]: https://github.com/3Hren/msgpack-rust\n[TOML]: https://github.com/alexcrichton/toml-rs\n[Pickle]: https://github.com/birkenfeld/serde-pickle\n[RON]: https://github.com/ron-rs/ron\n[BSON]: https://github.com/zonyitoo/bson-rs\n[Avro]: https://github.com/flavray/avro-rs\n[JSON5]: https://github.com/callum-oakley/json5-rs\n[Postcard]: https://github.com/jamesmunns/postcard\n[URL]: https://docs.rs/serde_qs\n[Envy]: https://github.com/softprops/envy\n[Envy Store]: https://github.com/softprops/envy-store\n[Cargo]: https://doc.rust-lang.org/cargo/reference/manifest.html\n[AWS Parameter Store]: https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-paramstore.html\n[S-expressions]: https://github.com/rotty/lexpr-rs\n[D-Bus]: https://docs.rs/zvariant\n[FlexBuffers]: https://github.com/google/flatbuffers/tree/master/rust/flexbuffers\n[DynamoDB Items]: https://docs.rs/serde_dynamo\n[rusoto_dynamodb]: https://docs.rs/rusoto_dynamodb"          },          filterText = "serde",          kind = 9,          label = "serde",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2925              },              start = {                character = 6,                line = 2925              }            },            newText = "serde",            replace = {              end = {                character = 13,                line = 2925              },              start = {                character = 6,                line = 2925              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "# Strum\n\nStrum is a set of macros and traits for working with\nenums and strings easier in Rust."          },          filterText = "strum_macros",          kind = 9,          label = "strum_macros",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2925              },              start = {                character = 6,                line = 2925              }            },            newText = "strum_macros",            replace = {              end = {                character = 13,                line = 2925              },              start = {                character = 6,                line = 2925              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "# The Rust Standard Library\n\nThe Rust Standard Library is the foundation of portable Rust software, a\nset of minimal and battle-tested shared abstractions for the [broader Rust\necosystem][crates.io]. It offers core types, like [`Vec<T>`] and\n[`Option<T>`], library-defined [operations on language\nprimitives](#primitives), [standard macros](#macros), [I/O] and\n[multithreading], among [many other things][other].\n\n`std` is available to all Rust crates by default. Therefore, the\nstandard library can be accessed in [`use`] statements through the path\n`std`, as in [`use std::env`].\n\n# How to read this documentation\n\nIf you already know the name of what you are looking for, the fastest way to\nfind it is to use the <a href=\"#\" onclick=\"focusSearchBar();\">search\nbar</a> at the top of the page.\n\nOtherwise, you may want to jump to one of these useful sections:\n\n* [`std::*` modules](#modules)\n* [Primitive types](#primitives)\n* [Standard macros](#macros)\n* [The Rust Prelude]\n\nIf this is your first time, the documentation for the standard library is\nwritten to be casually perused. Clicking on interesting things should\ngenerally lead you to interesting places. Still, there are important bits\nyou don't want to miss, so read on for a tour of the standard library and\nits documentation!\n\nOnce you are familiar with the contents of the standard library you may\nbegin to find the verbosity of the prose distracting. At this stage in your\ndevelopment you may want to press the `[-]` button near the top of the\npage to collapse it into a more skimmable view.\n\nWhile you are looking at that `[-]` button also notice the `source`\nlink. Rust's API documentation comes with the source code and you are\nencouraged to read it. The standard library source is generally high\nquality and a peek behind the curtains is often enlightening.\n\n# What is in the standard library documentation?\n\nFirst of all, The Rust Standard Library is divided into a number of focused\nmodules, [all listed further down this page](#modules). These modules are\nthe bedrock upon which all of Rust is forged, and they have mighty names\nlike [`std::slice`] and [`std::cmp`]. Modules' documentation typically\nincludes an overview of the module along with examples, and are a smart\nplace to start familiarizing yourself with the library.\n\nSecond, implicit methods on [primitive types] are documented here. This can\nbe a source of confusion for two reasons:\n\n1. While primitives are implemented by the compiler, the standard library\n   implements methods directly on the primitive types (and it is the only\n   library that does so), which are [documented in the section on\n   primitives](#primitives).\n2. The standard library exports many modules *with the same name as\n   primitive types*. These define additional items related to the primitive\n   type, but not the all-important methods.\n\nSo for example there is a [page for the primitive type\n`i32`](primitive::i32) that lists all the methods that can be called on\n32-bit integers (very useful), and there is a [page for the module\n`std::i32`] that documents the constant values [`MIN`] and [`MAX`] (rarely\nuseful).\n\nNote the documentation for the primitives [`str`] and [`[T]`][prim@slice] (also\ncalled 'slice'). Many method calls on [`String`] and [`Vec<T>`] are actually\ncalls to methods on [`str`] and [`[T]`][prim@slice] respectively, via [deref\ncoercions][deref-coercions].\n\nThird, the standard library defines [The Rust Prelude], a small collection\nof items - mostly traits - that are imported into every module of every\ncrate. The traits in the prelude are pervasive, making the prelude\ndocumentation a good entry point to learning about the library.\n\nAnd finally, the standard library exports a number of standard macros, and\n[lists them on this page](#macros) (technically, not all of the standard\nmacros are defined by the standard library - some are defined by the\ncompiler - but they are documented here the same). Like the prelude, the\nstandard macros are imported by default into all crates.\n\n# Contributing changes to the documentation\n\nCheck out the rust contribution guidelines [here](\nhttps://rustc-dev-guide.rust-lang.org/contributing.html#writing-documentation).\nThe source for this documentation can be found on\n[GitHub](https://github.com/rust-lang/rust).\nTo contribute changes, make sure you read the guidelines first, then submit\npull-requests for your suggested changes.\n\nContributions are appreciated! If you see a part of the docs that can be\nimproved, submit a PR, or chat with us first on [Discord][rust-discord]\n#docs.\n\n# A Tour of The Rust Standard Library\n\nThe rest of this crate documentation is dedicated to pointing out notable\nfeatures of The Rust Standard Library.\n\n## Containers and collections\n\nThe [`option`] and [`result`] modules define optional and error-handling\ntypes, [`Option<T>`] and [`Result<T, E>`]. The [`iter`] module defines\nRust's iterator trait, [`Iterator`], which works with the [`for`] loop to\naccess collections.\n\nThe standard library exposes three common ways to deal with contiguous\nregions of memory:\n\n* [`Vec<T>`] - A heap-allocated *vector* that is resizable at runtime.\n* [`[T; N]`][prim@array] - An inline *array* with a fixed size at compile time.\n* [`[T]`][prim@slice] - A dynamically sized *slice* into any other kind of contiguous\n  storage, whether heap-allocated or not.\n\nSlices can only be handled through some kind of *pointer*, and as such come\nin many flavors such as:\n\n* `&[T]` - *shared slice*\n* `&mut [T]` - *mutable slice*\n* [`Box<[T]>`][owned slice] - *owned slice*\n\n[`str`], a UTF-8 string slice, is a primitive type, and the standard library\ndefines many methods for it. Rust [`str`]s are typically accessed as\nimmutable references: `&str`. Use the owned [`String`] for building and\nmutating strings.\n\nFor converting to strings use the [`format!`] macro, and for converting from\nstrings use the [`FromStr`] trait.\n\nData may be shared by placing it in a reference-counted box or the [`Rc`]\ntype, and if further contained in a [`Cell`] or [`RefCell`], may be mutated\nas well as shared. Likewise, in a concurrent setting it is common to pair an\natomically-reference-counted box, [`Arc`], with a [`Mutex`] to get the same\neffect.\n\nThe [`collections`] module defines maps, sets, linked lists and other\ntypical collection types, including the common [`HashMap<K, V>`].\n\n## Platform abstractions and I/O\n\nBesides basic data types, the standard library is largely concerned with\nabstracting over differences in common platforms, most notably Windows and\nUnix derivatives.\n\nCommon types of I/O, including [files], [TCP], [UDP], are defined in the\n[`io`], [`fs`], and [`net`] modules.\n\nThe [`thread`] module contains Rust's threading abstractions. [`sync`]\ncontains further primitive shared memory types, including [`atomic`] and\n[`mpsc`], which contains the channel types for message passing.\n\n[I/O]: io\n[`MIN`]: i32::MIN\n[`MAX`]: i32::MAX\n[page for the module `std::i32`]: crate::i32\n[TCP]: net::TcpStream\n[The Rust Prelude]: prelude\n[UDP]: net::UdpSocket\n[`Arc`]: sync::Arc\n[owned slice]: boxed\n[`Cell`]: cell::Cell\n[`FromStr`]: str::FromStr\n[`HashMap<K, V>`]: collections::HashMap\n[`Mutex`]: sync::Mutex\n[`Option<T>`]: option::Option\n[`Rc`]: rc::Rc\n[`RefCell`]: cell::RefCell\n[`Result<T, E>`]: result::Result\n[`Vec<T>`]: vec::Vec\n[`atomic`]: sync::atomic\n[`for`]: ../book/ch03-05-control-flow.html#looping-through-a-collection-with-for\n[`str`]: prim@str\n[`mpsc`]: sync::mpsc\n[`std::cmp`]: cmp\n[`std::slice`]: mod@slice\n[`use std::env`]: env/index.html\n[`use`]: ../book/ch07-02-defining-modules-to-control-scope-and-privacy.html\n[crates.io]: https://crates.io\n[deref-coercions]: ../book/ch15-02-deref.html#implicit-deref-coercions-with-functions-and-methods\n[files]: fs::File\n[multithreading]: thread\n[other]: #what-is-in-the-standard-library-documentation\n[primitive types]: ../book/ch03-02-data-types.html\n[rust-discord]: https://discord.gg/rust-lang\n[array]: prim@array\n[slice]: prim@slice"          },          filterText = "std",          kind = 9,          label = "std",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2925              },              start = {                character = 6,                line = 2925              }            },            newText = "std",            replace = {              end = {                character = 13,                line = 2925              },              start = {                character = 6,                line = 2925              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "[![github]](https://github.com/dtolnay/semver)&ensp;[![crates-io]](https://crates.io/crates/semver)&ensp;[![docs-rs]](https://docs.rs/semver)\n\n[github]: https://img.shields.io/badge/github-8da0cb?style=for-the-badge&labelColor=555555&logo=github\n[crates-io]: https://img.shields.io/badge/crates.io-fc8d62?style=for-the-badge&labelColor=555555&logo=rust\n[docs-rs]: https://img.shields.io/badge/docs.rs-66c2a5?style=for-the-badge&labelColor=555555&logoColor=white&logo=data:image/svg+xml;base64,PHN2ZyByb2xlPSJpbWciIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyIgdmlld0JveD0iMCAwIDUxMiA1MTIiPjxwYXRoIGZpbGw9IiNmNWY1ZjUiIGQ9Ik00ODguNiAyNTAuMkwzOTIgMjE0VjEwNS41YzAtMTUtOS4zLTI4LjQtMjMuNC0zMy43bC0xMDAtMzcuNWMtOC4xLTMuMS0xNy4xLTMuMS0yNS4zIDBsLTEwMCAzNy41Yy0xNC4xIDUuMy0yMy40IDE4LjctMjMuNCAzMy43VjIxNGwtOTYuNiAzNi4yQzkuMyAyNTUuNSAwIDI2OC45IDAgMjgzLjlWMzk0YzAgMTMuNiA3LjcgMjYuMSAxOS45IDMyLjJsMTAwIDUwYzEwLjEgNS4xIDIyLjEgNS4xIDMyLjIgMGwxMDMuOS01MiAxMDMuOSA1MmMxMC4xIDUuMSAyMi4xIDUuMSAzMi4yIDBsMTAwLTUwYzEyLjItNi4xIDE5LjktMTguNiAxOS45LTMyLjJWMjgzLjljMC0xNS05LjMtMjguNC0yMy40LTMzLjd6TTM1OCAyMTQuOGwtODUgMzEuOXYtNjguMmw4NS0zN3Y3My4zek0xNTQgMTA0LjFsMTAyLTM4LjIgMTAyIDM4LjJ2LjZsLTEwMiA0MS40LTEwMi00MS40di0uNnptODQgMjkxLjFsLTg1IDQyLjV2LTc5LjFsODUtMzguOHY3NS40em0wLTExMmwtMTAyIDQxLjQtMTAyLTQxLjR2LS42bDEwMi0zOC4yIDEwMiAzOC4ydi42em0yNDAgMTEybC04NSA0Mi41di03OS4xbDg1LTM4Ljh2NzUuNHptMC0xMTJsLTEwMiA0MS40LTEwMi00MS40di0uNmwxMDItMzguMiAxMDIgMzguMnYuNnoiPjwvcGF0aD48L3N2Zz4K\n\n<br>\n\nA parser and evaluator for Cargo's flavor of Semantic Versioning.\n\nSemantic Versioning (see <https://semver.org>) is a guideline for how\nversion numbers are assigned and incremented. It is widely followed within\nthe Cargo/crates.io ecosystem for Rust.\n\n<br>\n\n# Example\n\n```rust\nuse semver::{BuildMetadata, Prerelease, Version, VersionReq};\n\nfn main() {\n    let req = VersionReq::parse(\">=1.2.3, <1.8.0\").unwrap();\n\n    // Check whether this requirement matches version 1.2.3-alpha.1 (no)\n    let version = Version {\n        major: 1,\n        minor: 2,\n        patch: 3,\n        pre: Prerelease::new(\"alpha.1\").unwrap(),\n        build: BuildMetadata::EMPTY,\n    };\n    assert!(!req.matches(&version));\n\n    // Check whether it matches 1.3.0 (yes it does)\n    let version = Version::parse(\"1.3.0\").unwrap();\n    assert!(req.matches(&version));\n}\n```\n\n<br><br>\n\n# Scope of this crate\n\nBesides Cargo, several other package ecosystems and package managers for\nother languages also use SemVer:&ensp;RubyGems/Bundler for Ruby, npm for\nJavaScript, Composer for PHP, CocoaPods for Objective-C...\n\nThe `semver` crate is specifically intended to implement Cargo's\ninterpretation of Semantic Versioning.\n\nWhere the various tools differ in their interpretation or implementation of\nthe spec, this crate follows the implementation choices made by Cargo. If\nyou are operating on version numbers from some other package ecosystem, you\nwill want to use a different semver library which is appropriate to that\necosystem.\n\nThe extent of Cargo's SemVer support is documented in the *[Specifying\nDependencies]* chapter of the Cargo reference.\n\n[Specifying Dependencies]: https://doc.rust-lang.org/cargo/reference/specifying-dependencies.html"          },          filterText = "semver",          kind = 9,          label = "semver",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2925              },              start = {                character = 6,                line = 2925              }            },            newText = "semver",            replace = {              end = {                character = 13,                line = 2925              },              start = {                character = 6,                line = 2925              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "# reqwest\n\nThe `reqwest` crate provides a convenient, higher-level HTTP\n[`Client`][client].\n\nIt handles many of the things that most people just expect an HTTP client\nto do for them.\n\n- Async and [blocking](blocking) Clients\n- Plain bodies, [JSON](#json), [urlencoded](#forms), [multipart](multipart)\n- Customizable [redirect policy](#redirect-policies)\n- HTTP [Proxies](#proxies)\n- Uses system-native [TLS](#tls)\n- Cookies\n\nThe [`reqwest::Client`][client] is asynchronous. For applications wishing\nto only make a few HTTP requests, the [`reqwest::blocking`](blocking) API\nmay be more convenient.\n\nAdditional learning resources include:\n\n- [The Rust Cookbook](https://rust-lang-nursery.github.io/rust-cookbook/web/clients.html)\n- [Reqwest Repository Examples](https://github.com/seanmonstar/reqwest/tree/master/examples)\n\n## Making a GET request\n\nFor a single request, you can use the [`get`][get] shortcut method.\n\n```rust\nlet body = reqwest::get(\"https://www.rust-lang.org\")\n    .await?\n    .text()\n    .await?;\n\nprintln!(\"body = {:?}\", body);\n```\n\n**NOTE**: If you plan to perform multiple requests, it is best to create a\n[`Client`][client] and reuse it, taking advantage of keep-alive connection\npooling.\n\n## Making POST requests (or setting request bodies)\n\nThere are several ways you can set the body of a request. The basic one is\nby using the `body()` method of a [`RequestBuilder`][builder]. This lets you set the\nexact raw bytes of what the body should be. It accepts various types,\nincluding `String` and `Vec<u8>`. If you wish to pass a custom\ntype, you can use the `reqwest::Body` constructors.\n\n```rust\nlet client = reqwest::Client::new();\nlet res = client.post(\"http://httpbin.org/post\")\n    .body(\"the exact body that is sent\")\n    .send()\n    .await?;\n```\n\n### Forms\n\nIt's very common to want to send form data in a request body. This can be\ndone with any type that can be serialized into form data.\n\nThis can be an array of tuples, or a `HashMap`, or a custom type that\nimplements [`Serialize`][serde].\n\n```rust\n// This will POST a body of `foo=bar&baz=quux`\nlet params = [(\"foo\", \"bar\"), (\"baz\", \"quux\")];\nlet client = reqwest::Client::new();\nlet res = client.post(\"http://httpbin.org/post\")\n    .form(&params)\n    .send()\n    .await?;\n```\n\n### JSON\n\nThere is also a `json` method helper on the [`RequestBuilder`][builder] that works in\na similar fashion the `form` method. It can take any value that can be\nserialized into JSON. The feature `json` is required.\n\n```rust\n// This will POST a body of `{\"lang\":\"rust\",\"body\":\"json\"}`\nlet mut map = HashMap::new();\nmap.insert(\"lang\", \"rust\");\nmap.insert(\"body\", \"json\");\n\nlet client = reqwest::Client::new();\nlet res = client.post(\"http://httpbin.org/post\")\n    .json(&map)\n    .send()\n    .await?;\n```\n\n## Redirect Policies\n\nBy default, a `Client` will automatically handle HTTP redirects, having a\nmaximum redirect chain of 10 hops. To customize this behavior, a\n[`redirect::Policy`][redirect] can be used with a `ClientBuilder`.\n\n## Cookies\n\nThe automatic storing and sending of session cookies can be enabled with\nthe [`cookie_store`][ClientBuilder::cookie_store] method on `ClientBuilder`.\n\n## Proxies\n\n**NOTE**: System proxies are enabled by default.\n\nSystem proxies look in environment variables to set HTTP or HTTPS proxies.\n\n`HTTP_PROXY` or `http_proxy` provide http proxies for http connections while\n`HTTPS_PROXY` or `https_proxy` provide HTTPS proxies for HTTPS connections.\n\nThese can be overwritten by adding a [`Proxy`](Proxy) to `ClientBuilder`\ni.e. `let proxy = reqwest::Proxy::http(\"https://secure.example\")?;`\nor disabled by calling `ClientBuilder::no_proxy()`.\n\n`socks` feature is required if you have configured socks proxy like this:\n\n```bash\nexport https_proxy=socks5://127.0.0.1:1086\n```\n\n## TLS\n\nBy default, a `Client` will make use of system-native transport layer\nsecurity to connect to HTTPS destinations. This means schannel on Windows,\nSecurity-Framework on macOS, and OpenSSL on Linux.\n\n- Additional X509 certificates can be configured on a `ClientBuilder` with the\n  [`Certificate`](Certificate) type.\n- Client certificates can be add to a `ClientBuilder` with the\n  [`Identity`][Identity] type.\n- Various parts of TLS can also be configured or even disabled on the\n  `ClientBuilder`.\n\n## Optional Features\n\nThe following are a list of [Cargo features][cargo-features] that can be\nenabled or disabled:\n\n- **default-tls** *(enabled by default)*: Provides TLS support to connect\n  over HTTPS.\n- **native-tls**: Enables TLS functionality provided by `native-tls`.\n- **native-tls-vendored**: Enables the `vendored` feature of `native-tls`.\n- **native-tls-alpn**: Enables the `alpn` feature of `native-tls`.\n- **rustls-tls**: Enables TLS functionality provided by `rustls`.\n  Equivalent to `rustls-tls-webpki-roots`.\n- **rustls-tls-manual-roots**: Enables TLS functionality provided by `rustls`,\n  without setting any root certificates. Roots have to be specified manually.\n- **rustls-tls-webpki-roots**: Enables TLS functionality provided by `rustls`,\n  while using root certificates from the `webpki-roots` crate.\n- **rustls-tls-native-roots**: Enables TLS functionality provided by `rustls`,\n  while using root certificates from the `rustls-native-certs` crate.\n- **blocking**: Provides the [blocking][] client API.\n- **cookies**: Provides cookie session support.\n- **gzip**: Provides response body gzip decompression.\n- **brotli**: Provides response body brotli decompression.\n- **deflate**: Provides response body deflate decompression.\n- **json**: Provides serialization and deserialization for JSON bodies.\n- **multipart**: Provides functionality for multipart forms.\n- **stream**: Adds support for `futures::Stream`.\n- **socks**: Provides SOCKS5 proxy support.\n- **trust-dns**: Enables a trust-dns async resolver instead of default\n  threadpool using `getaddrinfo`.\n\n\n[hyper]: http://hyper.rs\n[blocking]: ./blocking/index.html\n[client]: ./struct.Client.html\n[response]: ./struct.Response.html\n[get]: ./fn.get.html\n[builder]: ./struct.RequestBuilder.html\n[serde]: http://serde.rs\n[redirect]: crate::redirect\n[Proxy]: ./struct.Proxy.html\n[cargo-features]: https://doc.rust-lang.org/stable/cargo/reference/manifest.html#the-features-section"          },          filterText = "reqwest",          kind = 9,          label = "reqwest",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2925              },              start = {                character = 6,                line = 2925              }            },            newText = "reqwest",            replace = {              end = {                character = 13,                line = 2925              },              start = {                character = 6,                line = 2925              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "# The Rust Core Library\n\nThe Rust Core Library is the dependency-free[^free] foundation of [The\nRust Standard Library](../std/index.html). It is the portable glue\nbetween the language and its libraries, defining the intrinsic and\nprimitive building blocks of all Rust code. It links to no\nupstream libraries, no system libraries, and no libc.\n\n[^free]: Strictly speaking, there are some symbols which are needed but\n         they aren't always necessary.\n\nThe core library is *minimal*: it isn't even aware of heap allocation,\nnor does it provide concurrency or I/O. These things require\nplatform integration, and this library is platform-agnostic.\n\n# How to use the core library\n\nPlease note that all of these details are currently not considered stable.\n\nThis library is built on the assumption of a few existing symbols:\n\n* `memcpy`, `memcmp`, `memset` - These are core memory routines which are\n  often generated by LLVM. Additionally, this library can make explicit\n  calls to these functions. Their signatures are the same as found in C.\n  These functions are often provided by the system libc, but can also be\n  provided by the [compiler-builtins crate](https://crates.io/crates/compiler_builtins).\n\n* `rust_begin_panic` - This function takes four arguments, a\n  `fmt::Arguments`, a `&'static str`, and two `u32`'s. These four arguments\n  dictate the panic message, the file at which panic was invoked, and the\n  line and column inside the file. It is up to consumers of this core\n  library to define this panic function; it is only required to never\n  return. This requires a `lang` attribute named `panic_impl`.\n\n* `rust_eh_personality` - is used by the failure mechanisms of the\n   compiler. This is often mapped to GCC's personality function, but crates\n   which do not trigger a panic can be assured that this function is never\n   called. The `lang` attribute is called `eh_personality`."          },          filterText = "core",          kind = 9,          label = "core",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2925              },              start = {                character = 6,                line = 2925              }            },            newText = "core",            replace = {              end = {                character = 13,                line = 2925              },              start = {                character = 6,                line = 2925              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = '# Strum\n\n[![Build Status](https://travis-ci.org/Peternator7/strum.svg?branch=master)](https://travis-ci.org/Peternator7/strum)\n[![Latest Version](https://img.shields.io/crates/v/strum.svg)](https://crates.io/crates/strum)\n[![Rust Documentation](https://docs.rs/strum/badge.svg)](https://docs.rs/strum)\n\nStrum is a set of macros and traits for working with\nenums and strings easier in Rust.\n\nThe full version of the README can be found on [Github](https://github.com/Peternator7/strum).\n\n# Including Strum in Your Project\n\nImport strum and `strum_macros` into your project by adding the following lines to your\nCargo.toml. `strum_macros` contains the macros needed to derive all the traits in Strum.\n\n```toml\n[dependencies]\nstrum = "0.24"\nstrum_macros = "0.24"\n\n# You can also access strum_macros exports directly through strum using the "derive" feature\nstrum = { version = "0.24", features = ["derive"] }\n```'          },          filterText = "strum",          kind = 9,          label = "strum",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2925              },              start = {                character = 6,                line = 2925              }            },            newText = "strum",            replace = {              end = {                character = 13,                line = 2925              },              start = {                character = 6,                line = 2925              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "# Overview\n\n`once_cell` provides two new cell-like types, [`unsync::OnceCell`] and [`sync::OnceCell`]. A `OnceCell`\nmight store arbitrary non-`Copy` types, can be assigned to at most once and provides direct access\nto the stored contents. The core API looks *roughly* like this (and there's much more inside, read on!):\n\n```rust\nimpl<T> OnceCell<T> {\n    const fn new() -> OnceCell<T> { ... }\n    fn set(&self, value: T) -> Result<(), T> { ... }\n    fn get(&self) -> Option<&T> { ... }\n}\n```\n\nNote that, like with [`RefCell`] and [`Mutex`], the `set` method requires only a shared reference.\nBecause of the single assignment restriction `get` can return a `&T` instead of `Ref<T>`\nor `MutexGuard<T>`.\n\nThe `sync` flavor is thread-safe (that is, implements the [`Sync`] trait), while the `unsync` one is not.\n\n[`unsync::OnceCell`]: unsync/struct.OnceCell.html\n[`sync::OnceCell`]: sync/struct.OnceCell.html\n[`RefCell`]: https://doc.rust-lang.org/std/cell/struct.RefCell.html\n[`Mutex`]: https://doc.rust-lang.org/std/sync/struct.Mutex.html\n[`Sync`]: https://doc.rust-lang.org/std/marker/trait.Sync.html\n\n# Recipes\n\n`OnceCell` might be useful for a variety of patterns.\n\n## Safe Initialization of Global Data\n\n```rust\nuse std::{env, io};\n\nuse once_cell::sync::OnceCell;\n\n#[derive(Debug)]\npub struct Logger {\n    // ...\n}\nstatic INSTANCE: OnceCell<Logger> = OnceCell::new();\n\nimpl Logger {\n    pub fn global() -> &'static Logger {\n        INSTANCE.get().expect(\"logger is not initialized\")\n    }\n\n    fn from_cli(args: env::Args) -> Result<Logger, std::io::Error> {\n       // ...\n    }\n}\n\nfn main() {\n    let logger = Logger::from_cli(env::args()).unwrap();\n    INSTANCE.set(logger).unwrap();\n    // use `Logger::global()` from now on\n}\n```\n\n## Lazy Initialized Global Data\n\nThis is essentially the `lazy_static!` macro, but without a macro.\n\n```rust\nuse std::{sync::Mutex, collections::HashMap};\n\nuse once_cell::sync::OnceCell;\n\nfn global_data() -> &'static Mutex<HashMap<i32, String>> {\n    static INSTANCE: OnceCell<Mutex<HashMap<i32, String>>> = OnceCell::new();\n    INSTANCE.get_or_init(|| {\n        let mut m = HashMap::new();\n        m.insert(13, \"Spica\".to_string());\n        m.insert(74, \"Hoyten\".to_string());\n        Mutex::new(m)\n    })\n}\n```\n\nThere are also the [`sync::Lazy`] and [`unsync::Lazy`] convenience types to streamline this pattern:\n\n```rust\nuse std::{sync::Mutex, collections::HashMap};\nuse once_cell::sync::Lazy;\n\nstatic GLOBAL_DATA: Lazy<Mutex<HashMap<i32, String>>> = Lazy::new(|| {\n    let mut m = HashMap::new();\n    m.insert(13, \"Spica\".to_string());\n    m.insert(74, \"Hoyten\".to_string());\n    Mutex::new(m)\n});\n\nfn main() {\n    println!(\"{:?}\", GLOBAL_DATA.lock().unwrap());\n}\n```\n\nNote that the variable that holds `Lazy` is declared as `static`, *not*\n`const`. This is important: using `const` instead compiles, but works wrong.\n\n[`sync::Lazy`]: sync/struct.Lazy.html\n[`unsync::Lazy`]: unsync/struct.Lazy.html\n\n## General purpose lazy evaluation\n\nUnlike `lazy_static!`, `Lazy` works with local variables.\n\n```rust\nuse once_cell::unsync::Lazy;\n\nfn main() {\n    let ctx = vec![1, 2, 3];\n    let thunk = Lazy::new(|| {\n        ctx.iter().sum::<i32>()\n    });\n    assert_eq!(*thunk, 6);\n}\n```\n\nIf you need a lazy field in a struct, you probably should use `OnceCell`\ndirectly, because that will allow you to access `self` during initialization.\n\n```rust\nuse std::{fs, path::PathBuf};\n\nuse once_cell::unsync::OnceCell;\n\nstruct Ctx {\n    config_path: PathBuf,\n    config: OnceCell<String>,\n}\n\nimpl Ctx {\n    pub fn get_config(&self) -> Result<&str, std::io::Error> {\n        let cfg = self.config.get_or_try_init(|| {\n            fs::read_to_string(&self.config_path)\n        })?;\n        Ok(cfg.as_str())\n    }\n}\n```\n\n## Lazily Compiled Regex\n\nThis is a `regex!` macro which takes a string literal and returns an\n*expression* that evaluates to a `&'static Regex`:\n\n```rust\nmacro_rules! regex {\n    ($re:literal $(,)?) => {{\n        static RE: once_cell::sync::OnceCell<regex::Regex> = once_cell::sync::OnceCell::new();\n        RE.get_or_init(|| regex::Regex::new($re).unwrap())\n    }};\n}\n```\n\nThis macro can be useful to avoid the \"compile regex on every loop iteration\" problem.\n\n## Runtime `include_bytes!`\n\nThe `include_bytes` macro is useful to include test resources, but it slows\ndown test compilation a lot. An alternative is to load the resources at\nruntime:\n\n```rust\nuse std::path::Path;\n\nuse once_cell::sync::OnceCell;\n\npub struct TestResource {\n    path: &'static str,\n    cell: OnceCell<Vec<u8>>,\n}\n\nimpl TestResource {\n    pub const fn new(path: &'static str) -> TestResource {\n        TestResource { path, cell: OnceCell::new() }\n    }\n    pub fn bytes(&self) -> &[u8] {\n        self.cell.get_or_init(|| {\n            let dir = std::env::var(\"CARGO_MANIFEST_DIR\").unwrap();\n            let path = Path::new(dir.as_str()).join(self.path);\n            std::fs::read(&path).unwrap_or_else(|_err| {\n                panic!(\"failed to load test resource: {}\", path.display())\n            })\n        }).as_slice()\n    }\n}\n\nstatic TEST_IMAGE: TestResource = TestResource::new(\"test_data/lena.png\");\n\n#[test]\nfn test_sobel_filter() {\n    let rgb: &[u8] = TEST_IMAGE.bytes();\n    // ...\n}\n```\n\n## `lateinit`\n\n`LateInit` type for delayed initialization. It is reminiscent of Kotlin's\n`lateinit` keyword and allows construction of cyclic data structures:\n\n\n```rust\nuse once_cell::sync::OnceCell;\n\n#[derive(Debug)]\npub struct LateInit<T> { cell: OnceCell<T> }\n\nimpl<T> LateInit<T> {\n    pub fn init(&self, value: T) {\n        assert!(self.cell.set(value).is_ok())\n    }\n}\n\nimpl<T> Default for LateInit<T> {\n    fn default() -> Self { LateInit { cell: OnceCell::default() } }\n}\n\nimpl<T> std::ops::Deref for LateInit<T> {\n    type Target = T;\n    fn deref(&self) -> &T {\n        self.cell.get().unwrap()\n    }\n}\n\n#[derive(Default, Debug)]\nstruct A<'a> {\n    b: LateInit<&'a B<'a>>,\n}\n\n#[derive(Default, Debug)]\nstruct B<'a> {\n    a: LateInit<&'a A<'a>>\n}\n\nfn build_cycle() {\n    let a = A::default();\n    let b = B::default();\n    a.b.init(&b);\n    b.a.init(&a);\n    println!(\"{:?}\", a.b.a.b.a);\n}\n```\n\n# Comparison with std\n\n|`!Sync` types         | Access Mode            | Drawbacks                                     |\n|----------------------|------------------------|-----------------------------------------------|\n|`Cell<T>`             | `T`                    | requires `T: Copy` for `get`                  |\n|`RefCell<T>`          | `RefMut<T>` / `Ref<T>` | may panic at runtime                          |\n|`unsync::OnceCell<T>` | `&T`                   | assignable only once                          |\n\n|`Sync` types          | Access Mode            | Drawbacks                                     |\n|----------------------|------------------------|-----------------------------------------------|\n|`AtomicT`             | `T`                    | works only with certain `Copy` types          |\n|`Mutex<T>`            | `MutexGuard<T>`        | may deadlock at runtime, may block the thread |\n|`sync::OnceCell<T>`   | `&T`                   | assignable only once, may block the thread    |\n\nTechnically, calling `get_or_init` will also cause a panic or a deadlock if it recursively calls\nitself. However, because the assignment can happen only once, such cases should be more rare than\nequivalents with `RefCell` and `Mutex`.\n\n# Minimum Supported `rustc` Version\n\nThis crate's minimum supported `rustc` version is `1.36.0`.\n\nIf only the `std` feature is enabled, MSRV will be updated conservatively.\nWhen using other features, like `parking_lot`, MSRV might be updated more frequently, up to the latest stable.\nIn both cases, increasing MSRV is *not* considered a semver-breaking change.\n\n# Implementation details\n\nThe implementation is based on the [`lazy_static`](https://github.com/rust-lang-nursery/lazy-static.rs/)\nand [`lazy_cell`](https://github.com/indiv0/lazycell/) crates and [`std::sync::Once`]. In some sense,\n`once_cell` just streamlines and unifies those APIs.\n\nTo implement a sync flavor of `OnceCell`, this crates uses either a custom\nre-implementation of `std::sync::Once` or `parking_lot::Mutex`. This is\ncontrolled by the `parking_lot` feature (disabled by default). Performance\nis the same for both cases, but the `parking_lot` based `OnceCell<T>` is\nsmaller by up to 16 bytes.\n\nThis crate uses `unsafe`.\n\n[`std::sync::Once`]: https://doc.rust-lang.org/std/sync/struct.Once.html\n\n# F.A.Q.\n\n**Should I use lazy_static or once_cell?**\n\nTo the first approximation, `once_cell` is both more flexible and more convenient than `lazy_static`\nand should be preferred.\n\nUnlike `once_cell`, `lazy_static` supports spinlock-based implementation of blocking which works with\n`#![no_std]`.\n\n`lazy_static` has received significantly more real world testing, but `once_cell` is also a widely\nused crate.\n\n**Should I use the sync or unsync flavor?**\n\nBecause Rust compiler checks thread safety for you, it's impossible to accidentally use `unsync` where\n`sync` is required. So, use `unsync` in single-threaded code and `sync` in multi-threaded. It's easy\nto switch between the two if code becomes multi-threaded later.\n\nAt the moment, `unsync` has an additional benefit that reentrant initialization causes a panic, which\nmight be easier to debug than a deadlock.\n\n# Related crates\n\n* [double-checked-cell](https://github.com/niklasf/double-checked-cell)\n* [lazy-init](https://crates.io/crates/lazy-init)\n* [lazycell](https://crates.io/crates/lazycell)\n* [mitochondria](https://crates.io/crates/mitochondria)\n* [lazy_static](https://crates.io/crates/lazy_static)\n\nMost of this crate's functionality is available in `std` in nightly Rust.\nSee the [tracking issue](https://github.com/rust-lang/rust/issues/74465)."          },          filterText = "once_cell",          kind = 9,          label = "once_cell",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2925              },              start = {                character = 6,                line = 2925              }            },            newText = "once_cell",            replace = {              end = {                character = 13,                line = 2925              },              start = {                character = 6,                line = 2925              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "[![github]](https://github.com/dtolnay/thiserror)&ensp;[![crates-io]](https://crates.io/crates/thiserror)&ensp;[![docs-rs]](https://docs.rs/thiserror)\n\n[github]: https://img.shields.io/badge/github-8da0cb?style=for-the-badge&labelColor=555555&logo=github\n[crates-io]: https://img.shields.io/badge/crates.io-fc8d62?style=for-the-badge&labelColor=555555&logo=rust\n[docs-rs]: https://img.shields.io/badge/docs.rs-66c2a5?style=for-the-badge&labelColor=555555&logoColor=white&logo=data:image/svg+xml;base64,PHN2ZyByb2xlPSJpbWciIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyIgdmlld0JveD0iMCAwIDUxMiA1MTIiPjxwYXRoIGZpbGw9IiNmNWY1ZjUiIGQ9Ik00ODguNiAyNTAuMkwzOTIgMjE0VjEwNS41YzAtMTUtOS4zLTI4LjQtMjMuNC0zMy43bC0xMDAtMzcuNWMtOC4xLTMuMS0xNy4xLTMuMS0yNS4zIDBsLTEwMCAzNy41Yy0xNC4xIDUuMy0yMy40IDE4LjctMjMuNCAzMy43VjIxNGwtOTYuNiAzNi4yQzkuMyAyNTUuNSAwIDI2OC45IDAgMjgzLjlWMzk0YzAgMTMuNiA3LjcgMjYuMSAxOS45IDMyLjJsMTAwIDUwYzEwLjEgNS4xIDIyLjEgNS4xIDMyLjIgMGwxMDMuOS01MiAxMDMuOSA1MmMxMC4xIDUuMSAyMi4xIDUuMSAzMi4yIDBsMTAwLTUwYzEyLjItNi4xIDE5LjktMTguNiAxOS45LTMyLjJWMjgzLjljMC0xNS05LjMtMjguNC0yMy40LTMzLjd6TTM1OCAyMTQuOGwtODUgMzEuOXYtNjguMmw4NS0zN3Y3My4zek0xNTQgMTA0LjFsMTAyLTM4LjIgMTAyIDM4LjJ2LjZsLTEwMiA0MS40LTEwMi00MS40di0uNnptODQgMjkxLjFsLTg1IDQyLjV2LTc5LjFsODUtMzguOHY3NS40em0wLTExMmwtMTAyIDQxLjQtMTAyLTQxLjR2LS42bDEwMi0zOC4yIDEwMiAzOC4ydi42em0yNDAgMTEybC04NSA0Mi41di03OS4xbDg1LTM4Ljh2NzUuNHptMC0xMTJsLTEwMiA0MS40LTEwMi00MS40di0uNmwxMDItMzguMiAxMDIgMzguMnYuNnoiPjwvcGF0aD48L3N2Zz4K\n\n<br>\n\nThis library provides a convenient derive macro for the standard library's\n[`std::error::Error`] trait.\n\n[`std::error::Error`]: https://doc.rust-lang.org/std/error/trait.Error.html\n\n<br>\n\n# Example\n\n```rust\nuse thiserror::Error;\n\n#[derive(Error, Debug)]\npub enum DataStoreError {\n    #[error(\"data store disconnected\")]\n    Disconnect(#[from] io::Error),\n    #[error(\"the data for key `{0}` is not available\")]\n    Redaction(String),\n    #[error(\"invalid header (expected {expected:?}, found {found:?})\")]\n    InvalidHeader {\n        expected: String,\n        found: String,\n    },\n    #[error(\"unknown data store error\")]\n    Unknown,\n}\n```\n\n<br>\n\n# Details\n\n- Thiserror deliberately does not appear in your public API. You get the\n  same thing as if you had written an implementation of `std::error::Error`\n  by hand, and switching from handwritten impls to thiserror or vice versa\n  is not a breaking change.\n\n- Errors may be enums, structs with named fields, tuple structs, or unit\n  structs.\n\n- A `Display` impl is generated for your error if you provide\n  `#[error(\"...\")]` messages on the struct or each variant of your enum, as\n  shown above in the example.\n\n  The messages support a shorthand for interpolating fields from the error.\n\n    - `#[error(\"{var}\")]`&ensp;⟶&ensp;`write!(\"{}\", self.var)`\n    - `#[error(\"{0}\")]`&ensp;⟶&ensp;`write!(\"{}\", self.0)`\n    - `#[error(\"{var:?}\")]`&ensp;⟶&ensp;`write!(\"{:?}\", self.var)`\n    - `#[error(\"{0:?}\")]`&ensp;⟶&ensp;`write!(\"{:?}\", self.0)`\n\n  These shorthands can be used together with any additional format args,\n  which may be arbitrary expressions. For example:\n\n  ```rust\n  # use std::i32;\n  # use thiserror::Error;\n  #\n  #[derive(Error, Debug)]\n  pub enum Error {\n      #[error(\"invalid rdo_lookahead_frames {0} (expected < {})\", i32::MAX)]\n      InvalidLookahead(u32),\n  }\n  ```\n\n  If one of the additional expression arguments needs to refer to a field of\n  the struct or enum, then refer to named fields as `.var` and tuple fields\n  as `.0`.\n\n  ```rust\n  # use thiserror::Error;\n  #\n  # fn first_char(s: &String) -> char {\n  #     s.chars().next().unwrap()\n  # }\n  #\n  # #[derive(Debug)]\n  # struct Limits {\n  #     lo: usize,\n  #     hi: usize,\n  # }\n  #\n  #[derive(Error, Debug)]\n  pub enum Error {\n      #[error(\"first letter must be lowercase but was {:?}\", first_char(.0))]\n      WrongCase(String),\n      #[error(\"invalid index {idx}, expected at least {} and at most {}\", .limits.lo, .limits.hi)]\n      OutOfBounds { idx: usize, limits: Limits },\n  }\n  ```\n\n- A `From` impl is generated for each variant containing a `#[from]`\n  attribute.\n\n  Note that the variant must not contain any other fields beyond the source\n  error and possibly a backtrace. A backtrace is captured from within the\n  `From` impl if there is a field for it.\n\n  ```rust\n  # const IGNORE: &str = stringify! {\n  #[derive(Error, Debug)]\n  pub enum MyError {\n      Io {\n          #[from]\n          source: io::Error,\n          backtrace: Backtrace,\n      },\n  }\n  # };\n  ```\n\n- The Error trait's `source()` method is implemented to return whichever\n  field has a `#[source]` attribute or is named `source`, if any. This is\n  for identifying the underlying lower level error that caused your error.\n\n  The `#[from]` attribute always implies that the same field is `#[source]`,\n  so you don't ever need to specify both attributes.\n\n  Any error type that implements `std::error::Error` or dereferences to `dyn\n  std::error::Error` will work as a source.\n\n  ```rust\n  # use std::fmt::{self, Display};\n  # use thiserror::Error;\n  #\n  #[derive(Error, Debug)]\n  pub struct MyError {\n      msg: String,\n      #[source]  // optional if field name is `source`\n      source: anyhow::Error,\n  }\n  #\n  # impl Display for MyError {\n  #     fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {\n  #         unimplemented!()\n  #     }\n  # }\n  ```\n\n- The Error trait's `backtrace()` method is implemented to return whichever\n  field has a type named `Backtrace`, if any.\n\n  ```rust\n  # const IGNORE: &str = stringify! {\n  use std::backtrace::Backtrace;\n\n  #[derive(Error, Debug)]\n  pub struct MyError {\n      msg: String,\n      backtrace: Backtrace,  // automatically detected\n  }\n  # };\n  ```\n\n- If a field is both a source (named `source`, or has `#[source]` or\n  `#[from]` attribute) *and* is marked `#[backtrace]`, then the Error\n  trait's `backtrace()` method is forwarded to the source's backtrace.\n\n  ```rust\n  # const IGNORE: &str = stringify! {\n  #[derive(Error, Debug)]\n  pub enum MyError {\n      Io {\n          #[backtrace]\n          source: io::Error,\n      },\n  }\n  # };\n  ```\n\n- Errors may use `error(transparent)` to forward the source and Display\n  methods straight through to an underlying error without adding an\n  additional message. This would be appropriate for enums that need an\n  \"anything else\" variant.\n\n  ```\n  # use thiserror::Error;\n  #\n  #[derive(Error, Debug)]\n  pub enum MyError {\n      # /*\n      ...\n      # */\n\n      #[error(transparent)]\n      Other(#[from] anyhow::Error),  // source and Display delegate to anyhow::Error\n  }\n  ```\n\n- See also the [`anyhow`] library for a convenient single error type to use\n  in application code.\n\n  [`anyhow`]: https://github.com/dtolnay/anyhow"          },          filterText = "thiserror",          kind = 9,          label = "thiserror",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2925              },              start = {                character = 6,                line = 2925              }            },            newText = "thiserror",            replace = {              end = {                character = 13,                line = 2925              },              start = {                character = 6,                line = 2925              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "A runtime for writing reliable network applications without compromising speed.\n\nTokio is an event-driven, non-blocking I/O platform for writing asynchronous\napplications with the Rust programming language. At a high level, it\nprovides a few major components:\n\n* Tools for [working with asynchronous tasks][tasks], including\n  [synchronization primitives and channels][sync] and [timeouts, sleeps, and\n  intervals][time].\n* APIs for [performing asynchronous I/O][io], including [TCP and UDP][net] sockets,\n  [filesystem][fs] operations, and [process] and [signal] management.\n* A [runtime] for executing asynchronous code, including a task scheduler,\n  an I/O driver backed by the operating system's event queue (epoll, kqueue,\n  IOCP, etc...), and a high performance timer.\n\nGuide level documentation is found on the [website].\n\n[tasks]: #working-with-tasks\n[sync]: crate::sync\n[time]: crate::time\n[io]: #asynchronous-io\n[net]: crate::net\n[fs]: crate::fs\n[process]: crate::process\n[signal]: crate::signal\n[fs]: crate::fs\n[runtime]: crate::runtime\n[website]: https://tokio.rs/tokio/tutorial\n\n# A Tour of Tokio\n\nTokio consists of a number of modules that provide a range of functionality\nessential for implementing asynchronous applications in Rust. In this\nsection, we will take a brief tour of Tokio, summarizing the major APIs and\ntheir uses.\n\nThe easiest way to get started is to enable all features. Do this by\nenabling the `full` feature flag:\n\n```toml\ntokio = { version = \"1\", features = [\"full\"] }\n```\n\n### Authoring applications\n\nTokio is great for writing applications and most users in this case shouldn't\nworry too much about what features they should pick. If you're unsure, we suggest\ngoing with `full` to ensure that you don't run into any road blocks while you're\nbuilding your application.\n\n#### Example\n\nThis example shows the quickest way to get started with Tokio.\n\n```toml\ntokio = { version = \"1\", features = [\"full\"] }\n```\n\n### Authoring libraries\n\nAs a library author your goal should be to provide the lightest weight crate\nthat is based on Tokio. To achieve this you should ensure that you only enable\nthe features you need. This allows users to pick up your crate without having\nto enable unnecessary features.\n\n#### Example\n\nThis example shows how you may want to import features for a library that just\nneeds to `tokio::spawn` and use a `TcpStream`.\n\n```toml\ntokio = { version = \"1\", features = [\"rt\", \"net\"] }\n```\n\n## Working With Tasks\n\nAsynchronous programs in Rust are based around lightweight, non-blocking\nunits of execution called [_tasks_][tasks]. The [`tokio::task`] module provides\nimportant tools for working with tasks:\n\n* The [`spawn`] function and [`JoinHandle`] type, for scheduling a new task\n  on the Tokio runtime and awaiting the output of a spawned task, respectively,\n* Functions for [running blocking operations][blocking] in an asynchronous\n  task context.\n\nThe [`tokio::task`] module is present only when the \"rt\" feature flag\nis enabled.\n\n[tasks]: task/index.html#what-are-tasks\n[`tokio::task`]: crate::task\n[`spawn`]: crate::task::spawn()\n[`JoinHandle`]: crate::task::JoinHandle\n[blocking]: task/index.html#blocking-and-yielding\n\nThe [`tokio::sync`] module contains synchronization primitives to use when\nneeding to communicate or share data. These include:\n\n* channels ([`oneshot`], [`mpsc`], and [`watch`]), for sending values\n  between tasks,\n* a non-blocking [`Mutex`], for controlling access to a shared, mutable\n  value,\n* an asynchronous [`Barrier`] type, for multiple tasks to synchronize before\n  beginning a computation.\n\nThe `tokio::sync` module is present only when the \"sync\" feature flag is\nenabled.\n\n[`tokio::sync`]: crate::sync\n[`Mutex`]: crate::sync::Mutex\n[`Barrier`]: crate::sync::Barrier\n[`oneshot`]: crate::sync::oneshot\n[`mpsc`]: crate::sync::mpsc\n[`watch`]: crate::sync::watch\n\nThe [`tokio::time`] module provides utilities for tracking time and\nscheduling work. This includes functions for setting [timeouts][timeout] for\ntasks, [sleeping][sleep] work to run in the future, or [repeating an operation at an\ninterval][interval].\n\nIn order to use `tokio::time`, the \"time\" feature flag must be enabled.\n\n[`tokio::time`]: crate::time\n[sleep]: crate::time::sleep()\n[interval]: crate::time::interval()\n[timeout]: crate::time::timeout()\n\nFinally, Tokio provides a _runtime_ for executing asynchronous tasks. Most\napplications can use the [`#[tokio::main]`][main] macro to run their code on the\nTokio runtime. However, this macro provides only basic configuration options. As\nan alternative, the [`tokio::runtime`] module provides more powerful APIs for configuring\nand managing runtimes. You should use that module if the `#[tokio::main]` macro doesn't\nprovide the functionality you need.\n\nUsing the runtime requires the \"rt\" or \"rt-multi-thread\" feature flags, to\nenable the basic [single-threaded scheduler][rt] and the [thread-pool\nscheduler][rt-multi-thread], respectively. See the [`runtime` module\ndocumentation][rt-features] for details. In addition, the \"macros\" feature\nflag enables the `#[tokio::main]` and `#[tokio::test]` attributes.\n\n[main]: attr.main.html\n[`tokio::runtime`]: crate::runtime\n[`Builder`]: crate::runtime::Builder\n[`Runtime`]: crate::runtime::Runtime\n[rt]: runtime/index.html#current-thread-scheduler\n[rt-multi-thread]: runtime/index.html#multi-thread-scheduler\n[rt-features]: runtime/index.html#runtime-scheduler\n\n## CPU-bound tasks and blocking code\n\nTokio is able to concurrently run many tasks on a few threads by repeatedly\nswapping the currently running task on each thread. However, this kind of\nswapping can only happen at `.await` points, so code that spends a long time\nwithout reaching an `.await` will prevent other tasks from running. To\ncombat this, Tokio provides two kinds of threads: Core threads and blocking\nthreads. The core threads are where all asynchronous code runs, and Tokio\nwill by default spawn one for each CPU core. The blocking threads are\nspawned on demand, can be used to run blocking code that would otherwise\nblock other tasks from running and are kept alive when not used for a certain\namount of time which can be configured with [`thread_keep_alive`].\nSince it is not possible for Tokio to swap out blocking tasks, like it\ncan do with asynchronous code, the upper limit on the number of blocking\nthreads is very large. These limits can be configured on the [`Builder`].\n\nTo spawn a blocking task, you should use the [`spawn_blocking`] function.\n\n[`Builder`]: crate::runtime::Builder\n[`spawn_blocking`]: crate::task::spawn_blocking()\n[`thread_keep_alive`]: crate::runtime::Builder::thread_keep_alive()\n\n```rust\n#[tokio::main]\nasync fn main() {\n    // This is running on a core thread.\n\n    let blocking_task = tokio::task::spawn_blocking(|| {\n        // This is running on a blocking thread.\n        // Blocking here is ok.\n    });\n\n    // We can wait for the blocking task like this:\n    // If the blocking task panics, the unwrap below will propagate the\n    // panic.\n    blocking_task.await.unwrap();\n}\n```\n\nIf your code is CPU-bound and you wish to limit the number of threads used\nto run it, you should use a separate thread pool dedicated to CPU bound tasks.\nFor example, you could consider using the [rayon] library for CPU-bound\ntasks. It is also possible to create an extra Tokio runtime dedicated to\nCPU-bound tasks, but if you do this, you should be careful that the extra\nruntime runs _only_ CPU-bound tasks, as IO-bound tasks on that runtime\nwill behave poorly.\n\nHint: If using rayon, you can use a [`oneshot`] channel to send the result back\nto Tokio when the rayon task finishes.\n\n[rayon]: https://docs.rs/rayon\n[`oneshot`]: crate::sync::oneshot\n\n## Asynchronous IO\n\nAs well as scheduling and running tasks, Tokio provides everything you need\nto perform input and output asynchronously.\n\nThe [`tokio::io`] module provides Tokio's asynchronous core I/O primitives,\nthe [`AsyncRead`], [`AsyncWrite`], and [`AsyncBufRead`] traits. In addition,\nwhen the \"io-util\" feature flag is enabled, it also provides combinators and\nfunctions for working with these traits, forming as an asynchronous\ncounterpart to [`std::io`].\n\nTokio also includes APIs for performing various kinds of I/O and interacting\nwith the operating system asynchronously. These include:\n\n* [`tokio::net`], which contains non-blocking versions of [TCP], [UDP], and\n  [Unix Domain Sockets][UDS] (enabled by the \"net\" feature flag),\n* [`tokio::fs`], similar to [`std::fs`] but for performing filesystem I/O\n  asynchronously (enabled by the \"fs\" feature flag),\n* [`tokio::signal`], for asynchronously handling Unix and Windows OS signals\n  (enabled by the \"signal\" feature flag),\n* [`tokio::process`], for spawning and managing child processes (enabled by\n  the \"process\" feature flag).\n\n[`tokio::io`]: crate::io\n[`AsyncRead`]: crate::io::AsyncRead\n[`AsyncWrite`]: crate::io::AsyncWrite\n[`AsyncBufRead`]: crate::io::AsyncBufRead\n[`std::io`]: std::io\n[`tokio::net`]: crate::net\n[TCP]: crate::net::tcp\n[UDP]: crate::net::UdpSocket\n[UDS]: crate::net::unix\n[`tokio::fs`]: crate::fs\n[`std::fs`]: std::fs\n[`tokio::signal`]: crate::signal\n[`tokio::process`]: crate::process\n\n# Examples\n\nA simple TCP echo server:\n\n```rust\nuse tokio::net::TcpListener;\nuse tokio::io::{AsyncReadExt, AsyncWriteExt};\n\n#[tokio::main]\nasync fn main() -> Result<(), Box<dyn std::error::Error>> {\n    let listener = TcpListener::bind(\"127.0.0.1:8080\").await?;\n\n    loop {\n        let (mut socket, _) = listener.accept().await?;\n\n        tokio::spawn(async move {\n            let mut buf = [0; 1024];\n\n            // In a loop, read data from the socket and write the data back.\n            loop {\n                let n = match socket.read(&mut buf).await {\n                    // socket closed\n                    Ok(n) if n == 0 => return,\n                    Ok(n) => n,\n                    Err(e) => {\n                        eprintln!(\"failed to read from socket; err = {:?}\", e);\n                        return;\n                    }\n                };\n\n                // Write the data back\n                if let Err(e) = socket.write_all(&buf[0..n]).await {\n                    eprintln!(\"failed to write to socket; err = {:?}\", e);\n                    return;\n                }\n            }\n        });\n    }\n}\n```\n\n## Feature flags\n\nTokio uses a set of [feature flags] to reduce the amount of compiled code. It\nis possible to just enable certain features over others. By default, Tokio\ndoes not enable any features but allows one to enable a subset for their use\ncase. Below is a list of the available feature flags. You may also notice\nabove each function, struct and trait there is listed one or more feature flags\nthat are required for that item to be used. If you are new to Tokio it is\nrecommended that you use the `full` feature flag which will enable all public APIs.\nBeware though that this will pull in many extra dependencies that you may not\nneed.\n\n- `full`: Enables all features listed below except `test-util` and `tracing`.\n- `rt`: Enables `tokio::spawn`, the basic (current thread) scheduler,\n        and non-scheduler utilities.\n- `rt-multi-thread`: Enables the heavier, multi-threaded, work-stealing scheduler.\n- `io-util`: Enables the IO based `Ext` traits.\n- `io-std`: Enable `Stdout`, `Stdin` and `Stderr` types.\n- `net`: Enables `tokio::net` types such as `TcpStream`, `UnixStream` and\n         `UdpSocket`, as well as (on Unix-like systems) `AsyncFd` and (on\n         FreeBSD) `PollAio`.\n- `time`: Enables `tokio::time` types and allows the schedulers to enable\n          the built in timer.\n- `process`: Enables `tokio::process` types.\n- `macros`: Enables `#[tokio::main]` and `#[tokio::test]` macros.\n- `sync`: Enables all `tokio::sync` types.\n- `signal`: Enables all `tokio::signal` types.\n- `fs`: Enables `tokio::fs` types.\n- `test-util`: Enables testing based infrastructure for the Tokio runtime.\n\n_Note: `AsyncRead` and `AsyncWrite` traits do not require any features and are\nalways available._\n\n### Internal features\n\nThese features do not expose any new API, but influence internal\nimplementation aspects of Tokio, and can pull in additional\ndependencies.\n\n- `parking_lot`: As a potential optimization, use the _parking_lot_ crate's\nsynchronization primitives internally. MSRV may increase according to the\n_parking_lot_ release in use.\n\n### Unstable features\n\nThese feature flags enable **unstable** features. The public API may break in 1.x\nreleases. To enable these features, the `--cfg tokio_unstable` must be passed to\n`rustc` when compiling. This is easiest done using the `RUSTFLAGS` env variable:\n`RUSTFLAGS=\"--cfg tokio_unstable\"`.\n\n- `tracing`: Enables tracing events.\n\n[feature flags]: https://doc.rust-lang.org/cargo/reference/manifest.html#the-features-section"          },          filterText = "tokio",          kind = 9,          label = "tokio",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2925              },              start = {                character = 6,                line = 2925              }            },            newText = "tokio",            replace = {              end = {                character = 13,                line = 2925              },              start = {                character = 6,                line = 2925              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "This is a library to compare and sort strings (or file paths) **lexicographically**. This\nmeans that non-ASCII characters such as `á` or `ß` are treated like their closest ASCII\ncharacter: `á` is treated as `a`, `ß` is treated as `ss`, etc.\n\nLexical comparisons are case-insensitive. Alphanumeric characters are sorted after all other\ncharacters (punctuation, whitespace, special characters, emojis, ...).\n\nIt is possible to enable **natural sorting**, which also handles ASCII numbers. For example,\n`50` is less than `100` with natural sorting turned on. It's also possible to skip\ncharacters that aren't alphanumeric, so e.g. `f-5` is next to `f5`.\n\nIf different strings have the same ASCII representation (e.g. `\"Foo\"` and `\"fóò\"`), it\nfalls back to the default method from the standard library, so sorting is deterministic.\n\n<table><tr><td>\n<b>NOTE</b>: This crate doesn't attempt to be correct for every locale, but it should work\nreasonably well for a wide range of locales, while providing excellent performance.\n</td></tr></table>\n\n## Usage\n\nTo sort strings or paths, you can use the `StringSort` or `PathSort` trait:\n\n```rust\nuse lexical_sort::{StringSort, natural_lexical_cmp};\n\nlet mut strings = vec![\"ß\", \"é\", \"100\", \"hello\", \"world\", \"50\", \".\", \"B!\"];\nstrings.string_sort_unstable(natural_lexical_cmp);\n\nassert_eq!(&strings, &[\".\", \"50\", \"100\", \"B!\", \"é\", \"hello\", \"ß\", \"world\"]);\n```\n\nThere are eight comparison functions:\n\n| Function                         | lexico­graphical | natural | skips non-alphanumeric chars |\n| -------------------------------- |:---------------:|:-------:|:----------------------------:|\n| `cmp`                            |                 |         |                              |\n| `only_alnum_cmp`                 |                 |         | yes                          |\n| `lexical_cmp`                    | yes             |         |                              |\n| `lexical_only_alnum_cmp`         | yes             |         | yes                          |\n| `natural_cmp`                    |                 | yes     |                              |\n| `natural_only_alnum_cmp`         |                 | yes     | yes                          |\n| `natural_lexical_cmp`            | yes             | yes     |                              |\n| `natural_lexical_­only_alnum_cmp` | yes             | yes     | yes                          |\n\nNote that only the functions that sort lexicographically are case insensitive."          },          filterText = "lexical_sort",          kind = 9,          label = "lexical_sort",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2925              },              start = {                character = 6,                line = 2925              }            },            newText = "lexical_sort",            replace = {              end = {                character = 13,                line = 2925              },              start = {                character = 6,                line = 2925              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro cfg_accessible",          documentation = {            kind = "markdown",            value = "Keeps the item it's applied to if the passed path is accessible, and removes it otherwise."          },          filterText = "cfg_accessible",          kind = 3,          label = "cfg_accessible",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2925              },              start = {                character = 6,                line = 2925              }            },            newText = "cfg_accessible",            replace = {              end = {                character = 13,                line = 2925              },              start = {                character = 6,                line = 2925              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro test_case",          documentation = {            kind = "markdown",            value = "An implementation detail of the `#[test]` and `#[bench]` macros."          },          filterText = "test_case",          kind = 3,          label = "test_case",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2925              },              start = {                character = 6,                line = 2925              }            },            newText = "test_case",            replace = {              end = {                character = 13,                line = 2925              },              start = {                character = 6,                line = 2925              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro derive",          documentation = {            kind = "markdown",            value = "Attribute macro used to apply derive macros.\n\nSee [the reference] for more info.\n\n[the reference]: ../../../reference/attributes/derive.html"          },          filterText = "derive",          kind = 3,          label = "derive",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2925              },              start = {                character = 6,                line = 2925              }            },            newText = "derive",            replace = {              end = {                character = 13,                line = 2925              },              start = {                character = 6,                line = 2925              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro test",          documentation = {            kind = "markdown",            value = "Attribute macro applied to a function to turn it into a unit test.\n\nSee [the reference] for more info.\n\n[the reference]: ../../../reference/attributes/testing.html#the-test-attribute"          },          filterText = "test",          kind = 3,          label = "test",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2925              },              start = {                character = 6,                line = 2925              }            },            newText = "test",            replace = {              end = {                character = 13,                line = 2925              },              start = {                character = 6,                line = 2925              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro bench",          documentation = {            kind = "markdown",            value = "Attribute macro applied to a function to turn it into a benchmark test."          },          filterText = "bench",          kind = 3,          label = "bench",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2925              },              start = {                character = 6,                line = 2925              }            },            newText = "bench",            replace = {              end = {                character = 13,                line = 2925              },              start = {                character = 6,                line = 2925              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro global_allocator",          documentation = {            kind = "markdown",            value = "Attribute macro applied to a static to register it as a global allocator.\n\nSee also [`std::alloc::GlobalAlloc`](../../../std/alloc/trait.GlobalAlloc.html)."          },          filterText = "global_allocator",          kind = 3,          label = "global_allocator",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2925              },              start = {                character = 6,                line = 2925              }            },            newText = "global_allocator",            replace = {              end = {                character = 13,                line = 2925              },              start = {                character = 6,                line = 2925              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro cfg_eval",          documentation = {            kind = "markdown",            value = "Expands all `#[cfg]` and `#[cfg_attr]` attributes in the code fragment it's applied to."          },          filterText = "cfg_eval",          kind = 3,          label = "cfg_eval",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2925              },              start = {                character = 6,                line = 2925              }            },            newText = "cfg_eval",            replace = {              end = {                character = 13,                line = 2925              },              start = {                character = 6,                line = 2925              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "self::",          kind = 14,          label = "self::",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2925              },              start = {                character = 6,                line = 2925              }            },            newText = "self::",            replace = {              end = {                character = 13,                line = 2925              },              start = {                character = 6,                line = 2925              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "super::",          kind = 14,          label = "super::",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2925              },              start = {                character = 6,                line = 2925              }            },            newText = "super::",            replace = {              end = {                character = 13,                line = 2925              },              start = {                character = 6,                line = 2925              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "crate::",          kind = 14,          label = "crate::",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2925              },              start = {                character = 6,                line = 2925              }            },            newText = "crate::",            replace = {              end = {                character = 13,                line = 2925              },              start = {                character = 6,                line = 2925              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "allow",          insertTextFormat = 2,          kind = 3,          label = "allow(…)",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2925              },              start = {                character = 6,                line = 2925              }            },            newText = "allow(${0:lint})",            replace = {              end = {                character = 13,                line = 2925              },              start = {                character = 6,                line = 2925              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "cfg",          insertTextFormat = 2,          kind = 3,          label = "cfg(…)",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2925              },              start = {                character = 6,                line = 2925              }            },            newText = "cfg(${0:predicate})",            replace = {              end = {                character = 13,                line = 2925              },              start = {                character = 6,                line = 2925              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "cfg_attr",          insertTextFormat = 2,          kind = 3,          label = "cfg_attr(…)",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2925              },              start = {                character = 6,                line = 2925              }            },            newText = "cfg_attr(${1:predicate}, ${0:attr})",            replace = {              end = {                character = 13,                line = 2925              },              start = {                character = 6,                line = 2925              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "deny",          insertTextFormat = 2,          kind = 3,          label = "deny(…)",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2925              },              start = {                character = 6,                line = 2925              }            },            newText = "deny(${0:lint})",            replace = {              end = {                character = 13,                line = 2925              },              start = {                character = 6,                line = 2925              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "forbid",          insertTextFormat = 2,          kind = 3,          label = "forbid(…)",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2925              },              start = {                character = 6,                line = 2925              }            },            newText = "forbid(${0:lint})",            replace = {              end = {                character = 13,                line = 2925              },              start = {                character = 6,                line = 2925              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "warn",          insertTextFormat = 2,          kind = 3,          label = "warn(…)",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2925              },              start = {                character = 6,                line = 2925              }            },            newText = "warn(${0:lint})",            replace = {              end = {                character = 13,                line = 2925              },              start = {                character = 6,                line = 2925              }            }          }        }, {          additionalTextEdits = {},          data = {            imports = { {                full_import_path = "std::default",                imported_name = "default"              } },            position = {              position = {                character = 7,                line = 2925              },              textDocument = {                uri = "file:///home/jtcf/rustworks/factorio-lib-rs/src/prototypes/mod.rs"              }            }          },          deprecated = false,          documentation = {            kind = "markdown",            value = "The `Default` trait for types which may have meaningful default values."          },          filterText = "default",          kind = 9,          label = "default (use std::default)",          sortText = "fffffff0",          textEdit = {            insert = {              end = {                character = 7,                line = 2925              },              start = {                character = 6,                line = 2925              }            },            newText = "default",            replace = {              end = {                character = 13,                line = 2925              },              start = {                character = 6,                line = 2925              }            }          }        } }    }  }}
[START][2022-06-08 11:22:52] LSP logging initiated
[START][2022-06-09 10:02:52] LSP logging initiated
[START][2022-06-09 10:07:23] LSP logging initiated
[ERROR][2022-06-09 10:07:34] .../vim/lsp/rpc.lua:534	"No callback found for server response id 2"
[ERROR][2022-06-09 10:07:34] .../lua/vim/lsp.lua:824	"LSP[rust_analyzer]"	"on_error"	{  code = "NO_RESULT_CALLBACK_FOUND",  err = {    id = 2,    jsonrpc = "2.0",    result = {      isIncomplete = true,      items = { {          additionalTextEdits = {},          deprecated = false,          filterText = "self::",          kind = 14,          label = "self::",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "self::",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "super::",          kind = 14,          label = "super::",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "super::",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "crate::",          kind = 14,          label = "crate::",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "crate::",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "u32",          kind = 22,          label = "u32",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "u32",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "bool",          kind = 22,          label = "bool",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "bool",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "u8",          kind = 22,          label = "u8",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "u8",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "isize",          kind = 22,          label = "isize",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "isize",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "u16",          kind = 22,          label = "u16",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "u16",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "u64",          kind = 22,          label = "u64",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "u64",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "u128",          kind = 22,          label = "u128",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "u128",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "f32",          kind = 22,          label = "f32",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "f32",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "i128",          kind = 22,          label = "i128",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "i128",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "i16",          kind = 22,          label = "i16",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "i16",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "str",          kind = 22,          label = "str",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "str",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "i64",          kind = 22,          label = "i64",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "i64",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "char",          kind = 22,          label = "char",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "char",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "f64",          kind = 22,          label = "f64",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "f64",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "i32",          kind = 22,          label = "i32",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "i32",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "i8",          kind = 22,          label = "i8",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "i8",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "usize",          kind = 22,          label = "usize",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "usize",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          command = {            command = "editor.action.triggerParameterHints",            title = "triggerParameterHints"          },          deprecated = false,          detail = "fn(T) -> Result<String, Error>",          documentation = {            kind = "markdown",            value = 'Serializes a value into a `application/x-www-form-urlencoded` `String` buffer.\n\n```rust\nlet meal = &[\n    ("bread", "baguette"),\n    ("cheese", "comté"),\n    ("meat", "ham"),\n    ("fat", "butter"),\n];\n\nassert_eq!(\n    serde_urlencoded::to_string(meal),\n    Ok("bread=baguette&cheese=comt%C3%A9&meat=ham&fat=butter".to_owned()));\n```'          },          filterText = "to_string",          insertTextFormat = 2,          kind = 3,          label = "to_string(…)",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "to_string(${1:input})$0",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "PageSize",          kind = 13,          label = "PageSize",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "PageSize",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "ModPortalModsApiRequestParameters",          kind = 22,          label = "ModPortalModsApiRequestParameters",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "ModPortalModsApiRequestParameters",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "ModPortalRequestSort",          kind = 13,          label = "ModPortalRequestSort",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "ModPortalRequestSort",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "ModPortalRequestSortOrder",          kind = 13,          label = "ModPortalRequestSortOrder",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "ModPortalRequestSortOrder",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "async fn()",          filterText = "main",          insertTextFormat = 2,          kind = 3,          label = "main()",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "main()$0",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro_rules! eprint",          documentation = {            kind = "markdown",            value = 'Prints to the standard error.\n\nEquivalent to the [`print!`] macro, except that output goes to\n[`io::stderr`] instead of [`io::stdout`]. See [`print!`] for\nexample usage.\n\nUse `eprint!` only for error and progress messages. Use `print!`\ninstead for the primary output of your program.\n\n[`io::stderr`]: crate::io::stderr\n[`io::stdout`]: crate::io::stdout\n\n# Panics\n\nPanics if writing to `io::stderr` fails.\n\n# Examples\n\n```rust\neprint!("Error: Could not complete task");\n```'          },          filterText = "eprint",          kind = 3,          label = "eprint",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "eprint",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro_rules! panic",          filterText = "panic",          kind = 3,          label = "panic",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "panic",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro_rules! debug_assert_eq",          documentation = {            kind = "markdown",            value = "Asserts that two expressions are equal to each other.\n\nOn panic, this macro will print the values of the expressions with their\ndebug representations.\n\nUnlike [`assert_eq!`], `debug_assert_eq!` statements are only enabled in non\noptimized builds by default. An optimized build will not execute\n`debug_assert_eq!` statements unless `-C debug-assertions` is passed to the\ncompiler. This makes `debug_assert_eq!` useful for checks that are too\nexpensive to be present in a release build but may be helpful during\ndevelopment. The result of expanding `debug_assert_eq!` is always type checked.\n\n# Examples\n\n```rust\nlet a = 3;\nlet b = 1 + 2;\ndebug_assert_eq!(a, b);\n```"          },          filterText = "debug_assert_eq",          kind = 3,          label = "debug_assert_eq",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "debug_assert_eq",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro_rules! stringify",          documentation = {            kind = "markdown",            value = "Stringifies its arguments.\n\nThis macro will yield an expression of type `&'static str` which is the\nstringification of all the tokens passed to the macro. No restrictions\nare placed on the syntax of the macro invocation itself.\n\nNote that the expanded results of the input tokens may change in the\nfuture. You should be careful if you rely on the output.\n\n# Examples\n\n```rust\nlet one_plus_one = stringify!(1 + 1);\nassert_eq!(one_plus_one, \"1 + 1\");\n```"          },          filterText = "stringify",          kind = 3,          label = "stringify",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "stringify",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro_rules! concat",          documentation = {            kind = "markdown",            value = "Concatenates literals into a static string slice.\n\nThis macro takes any number of comma-separated literals, yielding an\nexpression of type `&'static str` which represents all of the literals\nconcatenated left-to-right.\n\nInteger and floating point literals are stringified in order to be\nconcatenated.\n\n# Examples\n\n```rust\nlet s = concat!(\"test\", 10, 'b', true);\nassert_eq!(s, \"test10btrue\");\n```"          },          filterText = "concat",          kind = 3,          label = "concat",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "concat",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro_rules! format",          documentation = {            kind = "markdown",            value = 'Creates a `String` using interpolation of runtime expressions.\n\nThe first argument `format!` receives is a format string. This must be a string\nliteral. The power of the formatting string is in the `{}`s contained.\n\nAdditional parameters passed to `format!` replace the `{}`s within the\nformatting string in the order given unless named or positional parameters\nare used; see [`std::fmt`] for more information.\n\nA common use for `format!` is concatenation and interpolation of strings.\nThe same convention is used with [`print!`] and [`write!`] macros,\ndepending on the intended destination of the string.\n\nTo convert a single value to a string, use the [`to_string`] method. This\nwill use the [`Display`] formatting trait.\n\n[`std::fmt`]: ../std/fmt/index.html\n[`print!`]: ../std/macro.print.html\n[`write!`]: core::write\n[`to_string`]: crate::string::ToString\n[`Display`]: core::fmt::Display\n\n# Panics\n\n`format!` panics if a formatting trait implementation returns an error.\nThis indicates an incorrect implementation\nsince `fmt::Write for String` never returns an error itself.\n\n# Examples\n\n```rust\nformat!("test");\nformat!("hello {}", "world!");\nformat!("x = {}, y = {y}", 10, y = 30);\n```'          },          filterText = "format",          kind = 3,          label = "format",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "format",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro_rules! log_syntax",          documentation = {            kind = "markdown",            value = "Prints passed tokens into the standard output."          },          filterText = "log_syntax",          kind = 3,          label = "log_syntax",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "log_syntax",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro_rules! include_str",          documentation = {            kind = "markdown",            value = "Includes a UTF-8 encoded file as a string.\n\nThe file is located relative to the current file (similarly to how\nmodules are found). The provided path is interpreted in a platform-specific\nway at compile time. So, for instance, an invocation with a Windows path\ncontaining backslashes `\\` would not compile correctly on Unix.\n\nThis macro will yield an expression of type `&'static str` which is the\ncontents of the file.\n\n# Examples\n\nAssume there are two files in the same directory with the following\ncontents:\n\nFile 'spanish.in':\n\n```text\nadiós\n```\n\nFile 'main.rs':\n\n```rust\nfn main() {\n    let my_str = include_str!(\"spanish.in\");\n    assert_eq!(my_str, \"adiós\\n\");\n    print!(\"{my_str}\");\n}\n```\n\nCompiling 'main.rs' and running the resulting binary will print \"adiós\"."          },          filterText = "include_str",          kind = 3,          label = "include_str",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "include_str",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro_rules! assert_ne",          documentation = {            kind = "markdown",            value = 'Asserts that two expressions are not equal to each other (using [`PartialEq`]).\n\nOn panic, this macro will print the values of the expressions with their\ndebug representations.\n\nLike [`assert!`], this macro has a second form, where a custom\npanic message can be provided.\n\n# Examples\n\n```rust\nlet a = 3;\nlet b = 2;\nassert_ne!(a, b);\n\nassert_ne!(a, b, "we are testing that the values are not equal");\n```'          },          filterText = "assert_ne",          kind = 3,          label = "assert_ne",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "assert_ne",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro_rules! dbg",          documentation = {            kind = "markdown",            value = "Prints and returns the value of a given expression for quick and dirty\ndebugging.\n\nAn example:\n\n```rust\nlet a = 2;\nlet b = dbg!(a * 2) + 1;\n//      ^-- prints: [src/main.rs:2] a * 2 = 4\nassert_eq!(b, 5);\n```\n\nThe macro works by using the `Debug` implementation of the type of\nthe given expression to print the value to [stderr] along with the\nsource location of the macro invocation as well as the source code\nof the expression.\n\nInvoking the macro on an expression moves and takes ownership of it\nbefore returning the evaluated expression unchanged. If the type\nof the expression does not implement `Copy` and you don't want\nto give up ownership, you can instead borrow with `dbg!(&expr)`\nfor some expression `expr`.\n\nThe `dbg!` macro works exactly the same in release builds.\nThis is useful when debugging issues that only occur in release\nbuilds or when debugging in release mode is significantly faster.\n\nNote that the macro is intended as a debugging tool and therefore you\nshould avoid having uses of it in version control for long periods\n(other than in tests and similar).\nDebug output from production code is better done with other facilities\nsuch as the [`debug!`] macro from the [`log`] crate.\n\n# Stability\n\nThe exact output printed by this macro should not be relied upon\nand is subject to future changes.\n\n# Panics\n\nPanics if writing to `io::stderr` fails.\n\n# Further examples\n\nWith a method call:\n\n```rust\nfn foo(n: usize) {\n    if let Some(_) = dbg!(n.checked_sub(4)) {\n        // ...\n    }\n}\n\nfoo(3)\n```\n\nThis prints to [stderr]:\n\n```text,ignore\n[src/main.rs:4] n.checked_sub(4) = None\n```\n\nNaive factorial implementation:\n\n```rust\nfn factorial(n: u32) -> u32 {\n    if dbg!(n <= 1) {\n        dbg!(1)\n    } else {\n        dbg!(n * factorial(n - 1))\n    }\n}\n\ndbg!(factorial(4));\n```\n\nThis prints to [stderr]:\n\n```text,ignore\n[src/main.rs:3] n <= 1 = false\n[src/main.rs:3] n <= 1 = false\n[src/main.rs:3] n <= 1 = false\n[src/main.rs:3] n <= 1 = true\n[src/main.rs:4] 1 = 1\n[src/main.rs:5] n * factorial(n - 1) = 2\n[src/main.rs:5] n * factorial(n - 1) = 6\n[src/main.rs:5] n * factorial(n - 1) = 24\n[src/main.rs:11] factorial(4) = 24\n```\n\nThe `dbg!(..)` macro moves the input:\n\n```rust\n/// A wrapper around `usize` which importantly is not Copyable.\n#[derive(Debug)]\nstruct NoCopy(usize);\n\nlet a = NoCopy(42);\nlet _ = dbg!(a); // <-- `a` is moved here.\nlet _ = dbg!(a); // <-- `a` is moved again; error!\n```\n\nYou can also use `dbg!()` without a value to just print the\nfile and line whenever it's reached.\n\nFinally, if you want to `dbg!(..)` multiple values, it will treat them as\na tuple (and return it, too):\n\n```rust\nassert_eq!(dbg!(1usize, 2u32), (1, 2));\n```\n\nHowever, a single argument with a trailing comma will still not be treated\nas a tuple, following the convention of ignoring trailing commas in macro\ninvocations. You can use a 1-tuple directly if you need one:\n\n```rust\nassert_eq!(1, dbg!(1u32,)); // trailing comma ignored\nassert_eq!((1,), dbg!((1u32,))); // 1-tuple\n```\n\n[stderr]: https://en.wikipedia.org/wiki/Standard_streams#Standard_error_(stderr)\n[`debug!`]: https://docs.rs/log/*/log/macro.debug.html\n[`log`]: https://crates.io/crates/log"          },          filterText = "dbg",          kind = 3,          label = "dbg",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "dbg",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro_rules! vec",          documentation = {            kind = "markdown",            value = "Creates a [`Vec`] containing the arguments.\n\n`vec!` allows `Vec`s to be defined with the same syntax as array expressions.\nThere are two forms of this macro:\n\n- Create a [`Vec`] containing a given list of elements:\n\n```rust\nlet v = vec![1, 2, 3];\nassert_eq!(v[0], 1);\nassert_eq!(v[1], 2);\nassert_eq!(v[2], 3);\n```\n\n- Create a [`Vec`] from a given element and size:\n\n```rust\nlet v = vec![1; 3];\nassert_eq!(v, [1, 1, 1]);\n```\n\nNote that unlike array expressions this syntax supports all elements\nwhich implement [`Clone`] and the number of elements doesn't have to be\na constant.\n\nThis will use `clone` to duplicate an expression, so one should be careful\nusing this with types having a nonstandard `Clone` implementation. For\nexample, `vec![Rc::new(1); 5]` will create a vector of five references\nto the same boxed integer value, not five references pointing to independently\nboxed integers.\n\nAlso, note that `vec![expr; 0]` is allowed, and produces an empty vector.\nThis will still evaluate `expr`, however, and immediately drop the resulting value, so\nbe mindful of side effects.\n\n[`Vec`]: crate::vec::Vec"          },          filterText = "vec",          kind = 3,          label = "vec",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "vec",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro_rules! include",          documentation = {            kind = "markdown",            value = "Parses a file as an expression or an item according to the context.\n\nThe file is located relative to the current file (similarly to how\nmodules are found). The provided path is interpreted in a platform-specific\nway at compile time. So, for instance, an invocation with a Windows path\ncontaining backslashes `\\` would not compile correctly on Unix.\n\nUsing this macro is often a bad idea, because if the file is\nparsed as an expression, it is going to be placed in the\nsurrounding code unhygienically. This could result in variables\nor functions being different from what the file expected if\nthere are variables or functions that have the same name in\nthe current file.\n\n# Examples\n\nAssume there are two files in the same directory with the following\ncontents:\n\nFile 'monkeys.in':\n\n```rust\n['🙈', '🙊', '🙉']\n    .iter()\n    .cycle()\n    .take(6)\n    .collect::<String>()\n```\n\nFile 'main.rs':\n\n```rust\nfn main() {\n    let my_string = include!(\"monkeys.in\");\n    assert_eq!(\"🙈🙊🙉🙈🙊🙉\", my_string);\n    println!(\"{my_string}\");\n}\n```\n\nCompiling 'main.rs' and running the resulting binary will print\n\"🙈🙊🙉🙈🙊🙉\"."          },          filterText = "include",          kind = 3,          label = "include",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "include",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro_rules! print",          documentation = {            kind = "markdown",            value = 'Prints to the standard output.\n\nEquivalent to the [`println!`] macro except that a newline is not printed at\nthe end of the message.\n\nNote that stdout is frequently line-buffered by default so it may be\nnecessary to use [`io::stdout().flush()`][flush] to ensure the output is emitted\nimmediately.\n\nUse `print!` only for the primary output of your program. Use\n[`eprint!`] instead to print error and progress messages.\n\n[flush]: crate::io::Write::flush\n\n# Panics\n\nPanics if writing to `io::stdout()` fails.\n\n# Examples\n\n```rust\nuse std::io::{self, Write};\n\nprint!("this ");\nprint!("will ");\nprint!("be ");\nprint!("on ");\nprint!("the ");\nprint!("same ");\nprint!("line ");\n\nio::stdout().flush().unwrap();\n\nprint!("this string has a newline, why not choose println! instead?\\n");\n\nio::stdout().flush().unwrap();\n```'          },          filterText = "print",          kind = 3,          label = "print",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "print",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro_rules! concat_idents",          documentation = {            kind = "markdown",            value = 'Concatenates identifiers into one identifier.\n\nThis macro takes any number of comma-separated identifiers, and\nconcatenates them all into one, yielding an expression which is a new\nidentifier. Note that hygiene makes it such that this macro cannot\ncapture local variables. Also, as a general rule, macros are only\nallowed in item, statement or expression position. That means while\nyou may use this macro for referring to existing variables, functions or\nmodules etc, you cannot define a new one with it.\n\n# Examples\n\n```rust\n#![feature(concat_idents)]\n\nfn foobar() -> u32 { 23 }\n\nlet f = concat_idents!(foo, bar);\nprintln!("{}", f());\n\n// fn concat_idents!(new, fun, name) { } // not usable in this way!\n```'          },          filterText = "concat_idents",          kind = 3,          label = "concat_idents",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "concat_idents",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro_rules! write",          documentation = {            kind = "markdown",            value = "Writes formatted data into a buffer.\n\nThis macro accepts a 'writer', a format string, and a list of arguments. Arguments will be\nformatted according to the specified format string and the result will be passed to the writer.\nThe writer may be any value with a `write_fmt` method; generally this comes from an\nimplementation of either the [`fmt::Write`] or the [`io::Write`] trait. The macro\nreturns whatever the `write_fmt` method returns; commonly a [`fmt::Result`], or an\n[`io::Result`].\n\nSee [`std::fmt`] for more information on the format string syntax.\n\n[`std::fmt`]: ../std/fmt/index.html\n[`fmt::Write`]: crate::fmt::Write\n[`io::Write`]: ../std/io/trait.Write.html\n[`fmt::Result`]: crate::fmt::Result\n[`io::Result`]: ../std/io/type.Result.html\n\n# Examples\n\n```rust\nuse std::io::Write;\n\nfn main() -> std::io::Result<()> {\n    let mut w = Vec::new();\n    write!(&mut w, \"test\")?;\n    write!(&mut w, \"formatted {}\", \"arguments\")?;\n\n    assert_eq!(w, b\"testformatted arguments\");\n    Ok(())\n}\n```\n\nA module can import both `std::fmt::Write` and `std::io::Write` and call `write!` on objects\nimplementing either, as objects do not typically implement both. However, the module must\nimport the traits qualified so their names do not conflict:\n\n```rust\nuse std::fmt::Write as FmtWrite;\nuse std::io::Write as IoWrite;\n\nfn main() -> Result<(), Box<dyn std::error::Error>> {\n    let mut s = String::new();\n    let mut v = Vec::new();\n\n    write!(&mut s, \"{} {}\", \"abc\", 123)?; // uses fmt::Write::write_fmt\n    write!(&mut v, \"s = {:?}\", s)?; // uses io::Write::write_fmt\n    assert_eq!(v, b\"s = \\\"abc 123\\\"\");\n    Ok(())\n}\n```\n\nNote: This macro can be used in `no_std` setups as well.\nIn a `no_std` setup you are responsible for the implementation details of the components.\n\n```rust\nuse core::fmt::Write;\n\nstruct Example;\n\nimpl Write for Example {\n    fn write_str(&mut self, _s: &str) -> core::fmt::Result {\n         unimplemented!();\n    }\n}\n\nlet mut m = Example{};\nwrite!(&mut m, \"Hello World\").expect(\"Not written\");\n```"          },          filterText = "write",          kind = 3,          label = "write",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "write",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro_rules! line",          documentation = {            kind = "markdown",            value = 'Expands to the line number on which it was invoked.\n\nWith [`column!`] and [`file!`], these macros provide debugging information for\ndevelopers about the location within the source.\n\nThe expanded expression has type `u32` and is 1-based, so the first line\nin each file evaluates to 1, the second to 2, etc. This is consistent\nwith error messages by common compilers or popular editors.\nThe returned line is *not necessarily* the line of the `line!` invocation itself,\nbut rather the first macro invocation leading up to the invocation\nof the `line!` macro.\n\n# Examples\n\n```rust\nlet current_line = line!();\nprintln!("defined on line: {current_line}");\n```'          },          filterText = "line",          kind = 3,          label = "line",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "line",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro_rules! env",          documentation = {            kind = "markdown",            value = "Inspects an environment variable at compile time.\n\nThis macro will expand to the value of the named environment variable at\ncompile time, yielding an expression of type `&'static str`.\n\nIf the environment variable is not defined, then a compilation error\nwill be emitted. To not emit a compile error, use the [`option_env!`]\nmacro instead.\n\n# Examples\n\n```rust\nlet path: &'static str = env!(\"PATH\");\nprintln!(\"the $PATH variable at the time of compiling was: {path}\");\n```\n\nYou can customize the error message by passing a string as the second\nparameter:\n\n```rust\nlet doc: &'static str = env!(\"documentation\", \"what's that?!\");\n```\n\nIf the `documentation` environment variable is not defined, you'll get\nthe following error:\n\n```text\nerror: what's that?!\n```"          },          filterText = "env",          kind = 3,          label = "env",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "env",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro_rules! debug_assert",          documentation = {            kind = "markdown",            value = "Asserts that a boolean expression is `true` at runtime.\n\nThis will invoke the [`panic!`] macro if the provided expression cannot be\nevaluated to `true` at runtime.\n\nLike [`assert!`], this macro also has a second version, where a custom panic\nmessage can be provided.\n\n# Uses\n\nUnlike [`assert!`], `debug_assert!` statements are only enabled in non\noptimized builds by default. An optimized build will not execute\n`debug_assert!` statements unless `-C debug-assertions` is passed to the\ncompiler. This makes `debug_assert!` useful for checks that are too\nexpensive to be present in a release build but may be helpful during\ndevelopment. The result of expanding `debug_assert!` is always type checked.\n\nAn unchecked assertion allows a program in an inconsistent state to keep\nrunning, which might have unexpected consequences but does not introduce\nunsafety as long as this only happens in safe code. The performance cost\nof assertions, however, is not measurable in general. Replacing [`assert!`]\nwith `debug_assert!` is thus only encouraged after thorough profiling, and\nmore importantly, only in safe code!\n\n# Examples\n\n```rust\n// the panic message for these assertions is the stringified value of the\n// expression given.\ndebug_assert!(true);\n\nfn some_expensive_computation() -> bool { true } // a very simple function\ndebug_assert!(some_expensive_computation());\n\n// assert with a custom message\nlet x = true;\ndebug_assert!(x, \"x wasn't true!\");\n\nlet a = 3; let b = 27;\ndebug_assert!(a + b == 30, \"a = {}, b = {}\", a, b);\n```"          },          filterText = "debug_assert",          kind = 3,          label = "debug_assert",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "debug_assert",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro_rules! const_format_args",          documentation = {            kind = "markdown",            value = "Same as [`format_args`], but can be used in some const contexts.\n\nThis macro is used by the panic macros for the `const_panic` feature.\n\nThis macro will be removed once `format_args` is allowed in const contexts."          },          filterText = "const_format_args",          kind = 3,          label = "const_format_args",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "const_format_args",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro_rules! include_bytes",          documentation = {            kind = "markdown",            value = "Includes a file as a reference to a byte array.\n\nThe file is located relative to the current file (similarly to how\nmodules are found). The provided path is interpreted in a platform-specific\nway at compile time. So, for instance, an invocation with a Windows path\ncontaining backslashes `\\` would not compile correctly on Unix.\n\nThis macro will yield an expression of type `&'static [u8; N]` which is\nthe contents of the file.\n\n# Examples\n\nAssume there are two files in the same directory with the following\ncontents:\n\nFile 'spanish.in':\n\n```text\nadiós\n```\n\nFile 'main.rs':\n\n```rust\nfn main() {\n    let bytes = include_bytes!(\"spanish.in\");\n    assert_eq!(bytes, b\"adi\\xc3\\xb3s\\n\");\n    print!(\"{}\", String::from_utf8_lossy(bytes));\n}\n```\n\nCompiling 'main.rs' and running the resulting binary will print \"adiós\"."          },          filterText = "include_bytes",          kind = 3,          label = "include_bytes",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "include_bytes",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro_rules! thread_local",          documentation = {            kind = "markdown",            value = "Declare a new thread local storage key of type [`std::thread::LocalKey`].\n\n# Syntax\n\nThe macro wraps any number of static declarations and makes them thread local.\nPublicity and attributes for each static are allowed. Example:\n\n```rust\nuse std::cell::RefCell;\nthread_local! {\n    pub static FOO: RefCell<u32> = RefCell::new(1);\n\n    #[allow(unused)]\n    static BAR: RefCell<f32> = RefCell::new(1.0);\n}\n```\n\nSee [`LocalKey` documentation][`std::thread::LocalKey`] for more\ninformation.\n\n[`std::thread::LocalKey`]: crate::thread::LocalKey"          },          filterText = "thread_local",          kind = 3,          label = "thread_local",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "thread_local",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro_rules! file",          documentation = {            kind = "markdown",            value = "Expands to the file name in which it was invoked.\n\nWith [`line!`] and [`column!`], these macros provide debugging information for\ndevelopers about the location within the source.\n\nThe expanded expression has type `&'static str`, and the returned file\nis not the invocation of the `file!` macro itself, but rather the\nfirst macro invocation leading up to the invocation of the `file!`\nmacro.\n\n# Examples\n\n```rust\nlet this_file = file!();\nprintln!(\"defined in file: {this_file}\");\n```"          },          filterText = "file",          kind = 3,          label = "file",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "file",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro_rules! try",          documentation = {            kind = "markdown",            value = 'Unwraps a result or propagates its error.\n\nThe `?` operator was added to replace `try!` and should be used instead.\nFurthermore, `try` is a reserved word in Rust 2018, so if you must use\nit, you will need to use the [raw-identifier syntax][ris]: `r#try`.\n\n[ris]: https://doc.rust-lang.org/nightly/rust-by-example/compatibility/raw_identifiers.html\n\n`try!` matches the given [`Result`]. In case of the `Ok` variant, the\nexpression has the value of the wrapped value.\n\nIn case of the `Err` variant, it retrieves the inner error. `try!` then\nperforms conversion using `From`. This provides automatic conversion\nbetween specialized errors and more general ones. The resulting\nerror is then immediately returned.\n\nBecause of the early return, `try!` can only be used in functions that\nreturn [`Result`].\n\n# Examples\n\n```rust\nuse std::io;\nuse std::fs::File;\nuse std::io::prelude::*;\n\nenum MyError {\n    FileWriteError\n}\n\nimpl From<io::Error> for MyError {\n    fn from(e: io::Error) -> MyError {\n        MyError::FileWriteError\n    }\n}\n\n// The preferred method of quick returning Errors\nfn write_to_file_question() -> Result<(), MyError> {\n    let mut file = File::create("my_best_friends.txt")?;\n    file.write_all(b"This is a list of my best friends.")?;\n    Ok(())\n}\n\n// The previous method of quick returning Errors\nfn write_to_file_using_try() -> Result<(), MyError> {\n    let mut file = r#try!(File::create("my_best_friends.txt"));\n    r#try!(file.write_all(b"This is a list of my best friends."));\n    Ok(())\n}\n\n// This is equivalent to:\nfn write_to_file_using_match() -> Result<(), MyError> {\n    let mut file = r#try!(File::create("my_best_friends.txt"));\n    match file.write_all(b"This is a list of my best friends.") {\n        Ok(v) => v,\n        Err(e) => return Err(From::from(e)),\n    }\n    Ok(())\n}\n```'          },          filterText = "try",          kind = 3,          label = "try",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "try",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro_rules! assert",          documentation = {            kind = "markdown",            value = "Asserts that a boolean expression is `true` at runtime.\n\nThis will invoke the [`panic!`] macro if the provided expression cannot be\nevaluated to `true` at runtime.\n\n# Uses\n\nAssertions are always checked in both debug and release builds, and cannot\nbe disabled. See [`debug_assert!`] for assertions that are not enabled in\nrelease builds by default.\n\nUnsafe code may rely on `assert!` to enforce run-time invariants that, if\nviolated could lead to unsafety.\n\nOther use-cases of `assert!` include testing and enforcing run-time\ninvariants in safe code (whose violation cannot result in unsafety).\n\n# Custom Messages\n\nThis macro has a second form, where a custom panic message can\nbe provided with or without arguments for formatting. See [`std::fmt`]\nfor syntax for this form. Expressions used as format arguments will only\nbe evaluated if the assertion fails.\n\n[`std::fmt`]: ../std/fmt/index.html\n\n# Examples\n\n```rust\n// the panic message for these assertions is the stringified value of the\n// expression given.\nassert!(true);\n\nfn some_computation() -> bool { true } // a very simple function\n\nassert!(some_computation());\n\n// assert with a custom message\nlet x = true;\nassert!(x, \"x wasn't true!\");\n\nlet a = 3; let b = 27;\nassert!(a + b == 30, \"a = {}, b = {}\", a, b);\n```"          },          filterText = "assert",          kind = 3,          label = "assert",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "assert",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro_rules! column",          documentation = {            kind = "markdown",            value = 'Expands to the column number at which it was invoked.\n\nWith [`line!`] and [`file!`], these macros provide debugging information for\ndevelopers about the location within the source.\n\nThe expanded expression has type `u32` and is 1-based, so the first column\nin each line evaluates to 1, the second to 2, etc. This is consistent\nwith error messages by common compilers or popular editors.\nThe returned column is *not necessarily* the line of the `column!` invocation itself,\nbut rather the first macro invocation leading up to the invocation\nof the `column!` macro.\n\n# Examples\n\n```rust\nlet current_col = column!();\nprintln!("defined on column: {current_col}");\n```\n\n`column!` counts Unicode code points, not bytes or graphemes. As a result, the first two\ninvocations return the same value, but the third does not.\n\n```rust\nlet a = ("foobar", column!()).1;\nlet b = ("人之初性本善", column!()).1;\nlet c = ("f̅o̅o̅b̅a̅r̅", column!()).1; // Uses combining overline (U+0305)\n\nassert_eq!(a, b);\nassert_ne!(b, c);\n```'          },          filterText = "column",          kind = 3,          label = "column",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "column",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro_rules! format_args_nl",          documentation = {            kind = "markdown",            value = "Same as [`format_args`], but adds a newline in the end."          },          filterText = "format_args_nl",          kind = 3,          label = "format_args_nl",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "format_args_nl",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro_rules! unreachable",          documentation = {            kind = "markdown",            value = "Indicates unreachable code.\n\nThis is useful any time that the compiler can't determine that some code is unreachable. For\nexample:\n\n* Match arms with guard conditions.\n* Loops that dynamically terminate.\n* Iterators that dynamically terminate.\n\nIf the determination that the code is unreachable proves incorrect, the\nprogram immediately terminates with a [`panic!`].\n\nThe unsafe counterpart of this macro is the [`unreachable_unchecked`] function, which\nwill cause undefined behavior if the code is reached.\n\n[`unreachable_unchecked`]: crate::hint::unreachable_unchecked\n\n# Panics\n\nThis will always [`panic!`] because `unreachable!` is just a shorthand for `panic!` with a\nfixed, specific message.\n\nLike `panic!`, this macro has a second form for displaying custom values.\n\n# Examples\n\nMatch arms:\n\n```rust\nfn foo(x: Option<i32>) {\n    match x {\n        Some(n) if n >= 0 => println!(\"Some(Non-negative)\"),\n        Some(n) if n <  0 => println!(\"Some(Negative)\"),\n        Some(_)           => unreachable!(), // compile error if commented out\n        None              => println!(\"None\")\n    }\n}\n```\n\nIterators:\n\n```rust\nfn divide_by_three(x: u32) -> u32 { // one of the poorest implementations of x/3\n    for i in 0.. {\n        if 3*i < i { panic!(\"u32 overflow\"); }\n        if x < 3*i { return i-1; }\n    }\n    unreachable!(\"The loop should always return\");\n}\n```"          },          filterText = "unreachable",          kind = 3,          label = "unreachable",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "unreachable",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro_rules! eprintln",          documentation = {            kind = "markdown",            value = 'Prints to the standard error, with a newline.\n\nEquivalent to the [`println!`] macro, except that output goes to\n[`io::stderr`] instead of [`io::stdout`]. See [`println!`] for\nexample usage.\n\nUse `eprintln!` only for error and progress messages. Use `println!`\ninstead for the primary output of your program.\n\n[`io::stderr`]: crate::io::stderr\n[`io::stdout`]: crate::io::stdout\n\n# Panics\n\nPanics if writing to `io::stderr` fails.\n\n# Examples\n\n```rust\neprintln!("Error: Could not complete task");\n```'          },          filterText = "eprintln",          kind = 3,          label = "eprintln",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "eprintln",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro_rules! unimplemented",          documentation = {            kind = "markdown",            value = "Indicates unimplemented code by panicking with a message of \"not implemented\".\n\nThis allows your code to type-check, which is useful if you are prototyping or\nimplementing a trait that requires multiple methods which you don't plan to use all of.\n\nThe difference between `unimplemented!` and [`todo!`] is that while `todo!`\nconveys an intent of implementing the functionality later and the message is \"not yet\nimplemented\", `unimplemented!` makes no such claims. Its message is \"not implemented\".\nAlso some IDEs will mark `todo!`s.\n\n# Panics\n\nThis will always [`panic!`] because `unimplemented!` is just a shorthand for `panic!` with a\nfixed, specific message.\n\nLike `panic!`, this macro has a second form for displaying custom values.\n\n# Examples\n\nSay we have a trait `Foo`:\n\n```rust\ntrait Foo {\n    fn bar(&self) -> u8;\n    fn baz(&self);\n    fn qux(&self) -> Result<u64, ()>;\n}\n```\n\nWe want to implement `Foo` for 'MyStruct', but for some reason it only makes sense\nto implement the `bar()` function. `baz()` and `qux()` will still need to be defined\nin our implementation of `Foo`, but we can use `unimplemented!` in their definitions\nto allow our code to compile.\n\nWe still want to have our program stop running if the unimplemented methods are\nreached.\n\n```rust\nstruct MyStruct;\n\nimpl Foo for MyStruct {\n    fn bar(&self) -> u8 {\n        1 + 1\n    }\n\n    fn baz(&self) {\n        // It makes no sense to `baz` a `MyStruct`, so we have no logic here\n        // at all.\n        // This will display \"thread 'main' panicked at 'not implemented'\".\n        unimplemented!();\n    }\n\n    fn qux(&self) -> Result<u64, ()> {\n        // We have some logic here,\n        // We can add a message to unimplemented! to display our omission.\n        // This will display:\n        // \"thread 'main' panicked at 'not implemented: MyStruct isn't quxable'\".\n        unimplemented!(\"MyStruct isn't quxable\");\n    }\n}\n\nfn main() {\n    let s = MyStruct;\n    s.bar();\n}\n```"          },          filterText = "unimplemented",          kind = 3,          label = "unimplemented",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "unimplemented",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro_rules! cfg",          documentation = {            kind = "markdown",            value = 'Evaluates boolean combinations of configuration flags at compile-time.\n\nIn addition to the `#[cfg]` attribute, this macro is provided to allow\nboolean expression evaluation of configuration flags. This frequently\nleads to less duplicated code.\n\nThe syntax given to this macro is the same syntax as the [`cfg`]\nattribute.\n\n`cfg!`, unlike `#[cfg]`, does not remove any code and only evaluates to true or false. For\nexample, all blocks in an if/else expression need to be valid when `cfg!` is used for\nthe condition, regardless of what `cfg!` is evaluating.\n\n[`cfg`]: ../reference/conditional-compilation.html#the-cfg-attribute\n\n# Examples\n\n```rust\nlet my_directory = if cfg!(windows) {\n    "windows-specific-directory"\n} else {\n    "unix-directory"\n};\n```'          },          filterText = "cfg",          kind = 3,          label = "cfg",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "cfg",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro_rules! todo",          documentation = {            kind = "markdown",            value = "Indicates unfinished code.\n\nThis can be useful if you are prototyping and are just looking to have your\ncode typecheck.\n\nThe difference between [`unimplemented!`] and `todo!` is that while `todo!` conveys\nan intent of implementing the functionality later and the message is \"not yet\nimplemented\", `unimplemented!` makes no such claims. Its message is \"not implemented\".\nAlso some IDEs will mark `todo!`s.\n\n# Panics\n\nThis will always [`panic!`].\n\n# Examples\n\nHere's an example of some in-progress code. We have a trait `Foo`:\n\n```rust\ntrait Foo {\n    fn bar(&self);\n    fn baz(&self);\n}\n```\n\nWe want to implement `Foo` on one of our types, but we also want to work on\njust `bar()` first. In order for our code to compile, we need to implement\n`baz()`, so we can use `todo!`:\n\n```rust\nstruct MyStruct;\n\nimpl Foo for MyStruct {\n    fn bar(&self) {\n        // implementation goes here\n    }\n\n    fn baz(&self) {\n        // let's not worry about implementing baz() for now\n        todo!();\n    }\n}\n\nfn main() {\n    let s = MyStruct;\n    s.bar();\n\n    // we aren't even using baz(), so this is fine.\n}\n```"          },          filterText = "todo",          kind = 3,          label = "todo",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "todo",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro_rules! trace_macros",          documentation = {            kind = "markdown",            value = "Enables or disables tracing functionality used for debugging other macros."          },          filterText = "trace_macros",          kind = 3,          label = "trace_macros",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "trace_macros",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro_rules! module_path",          documentation = {            kind = "markdown",            value = 'Expands to a string that represents the current module path.\n\nThe current module path can be thought of as the hierarchy of modules\nleading back up to the crate root. The first component of the path\nreturned is the name of the crate currently being compiled.\n\n# Examples\n\n```rust\nmod test {\n    pub fn foo() {\n        assert!(module_path!().ends_with("test"));\n    }\n}\n\ntest::foo();\n```'          },          filterText = "module_path",          kind = 3,          label = "module_path",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "module_path",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro_rules! writeln",          documentation = {            kind = "markdown",            value = 'Write formatted data into a buffer, with a newline appended.\n\nOn all platforms, the newline is the LINE FEED character (`\\n`/`U+000A`) alone\n(no additional CARRIAGE RETURN (`\\r`/`U+000D`).\n\nFor more information, see [`write!`]. For information on the format string syntax, see\n[`std::fmt`].\n\n[`std::fmt`]: ../std/fmt/index.html\n\n# Examples\n\n```rust\nuse std::io::{Write, Result};\n\nfn main() -> Result<()> {\n    let mut w = Vec::new();\n    writeln!(&mut w)?;\n    writeln!(&mut w, "test")?;\n    writeln!(&mut w, "formatted {}", "arguments")?;\n\n    assert_eq!(&w[..], "\\ntest\\nformatted arguments\\n".as_bytes());\n    Ok(())\n}\n```\n\nA module can import both `std::fmt::Write` and `std::io::Write` and call `write!` on objects\nimplementing either, as objects do not typically implement both. However, the module must\nimport the traits qualified so their names do not conflict:\n\n```rust\nuse std::fmt::Write as FmtWrite;\nuse std::io::Write as IoWrite;\n\nfn main() -> Result<(), Box<dyn std::error::Error>> {\n    let mut s = String::new();\n    let mut v = Vec::new();\n\n    writeln!(&mut s, "{} {}", "abc", 123)?; // uses fmt::Write::write_fmt\n    writeln!(&mut v, "s = {:?}", s)?; // uses io::Write::write_fmt\n    assert_eq!(v, b"s = \\"abc 123\\\\n\\"\\n");\n    Ok(())\n}\n```'          },          filterText = "writeln",          kind = 3,          label = "writeln",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "writeln",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro_rules! option_env",          documentation = {            kind = "markdown",            value = "Optionally inspects an environment variable at compile time.\n\nIf the named environment variable is present at compile time, this will\nexpand into an expression of type `Option<&'static str>` whose value is\n`Some` of the value of the environment variable. If the environment\nvariable is not present, then this will expand to `None`. See\n[`Option<T>`][Option] for more information on this type.\n\nA compile time error is never emitted when using this macro regardless\nof whether the environment variable is present or not.\n\n# Examples\n\n```rust\nlet key: Option<&'static str> = option_env!(\"SECRET_KEY\");\nprintln!(\"the secret key might be: {key:?}\");\n```"          },          filterText = "option_env",          kind = 3,          label = "option_env",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "option_env",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro_rules! compile_error",          documentation = {            kind = "markdown",            value = "Causes compilation to fail with the given error message when encountered.\n\nThis macro should be used when a crate uses a conditional compilation strategy to provide\nbetter error messages for erroneous conditions. It's the compiler-level form of [`panic!`],\nbut emits an error during *compilation* rather than at *runtime*.\n\n# Examples\n\nTwo such examples are macros and `#[cfg]` environments.\n\nEmit better compiler error if a macro is passed invalid values. Without the final branch,\nthe compiler would still emit an error, but the error's message would not mention the two\nvalid values.\n\n```rust\nmacro_rules! give_me_foo_or_bar {\n    (foo) => {};\n    (bar) => {};\n    ($x:ident) => {\n        compile_error!(\"This macro only accepts `foo` or `bar`\");\n    }\n}\n\ngive_me_foo_or_bar!(neither);\n// ^ will fail at compile time with message \"This macro only accepts `foo` or `bar`\"\n```\n\nEmit compiler error if one of a number of features isn't available.\n\n```rust\n#[cfg(not(any(feature = \"foo\", feature = \"bar\")))]\ncompile_error!(\"Either feature \\\"foo\\\" or \\\"bar\\\" must be enabled for this crate.\");\n```"          },          filterText = "compile_error",          kind = 3,          label = "compile_error",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "compile_error",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro_rules! matches",          documentation = {            kind = "markdown",            value = "Returns whether the given expression matches any of the given patterns.\n\nLike in a `match` expression, the pattern can be optionally followed by `if`\nand a guard expression that has access to names bound by the pattern.\n\n# Examples\n\n```rust\nlet foo = 'f';\nassert!(matches!(foo, 'A'..='Z' | 'a'..='z'));\n\nlet bar = Some(4);\nassert!(matches!(bar, Some(x) if x > 2));\n```"          },          filterText = "matches",          kind = 3,          label = "matches",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "matches",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro_rules! println",          documentation = {            kind = "markdown",            value = 'Prints to the standard output, with a newline.\n\nOn all platforms, the newline is the LINE FEED character (`\\n`/`U+000A`) alone\n(no additional CARRIAGE RETURN (`\\r`/`U+000D`)).\n\nUse the [`format!`] syntax to write data to the standard output.\nSee [`std::fmt`] for more information.\n\nUse `println!` only for the primary output of your program. Use\n[`eprintln!`] instead to print error and progress messages.\n\n[`std::fmt`]: crate::fmt\n\n# Panics\n\nPanics if writing to [`io::stdout`] fails.\n\n[`io::stdout`]: crate::io::stdout\n\n# Examples\n\n```rust\nprintln!(); // prints just a newline\nprintln!("hello there!");\nprintln!("format {} arguments", "some");\n```'          },          filterText = "println",          kind = 3,          label = "println",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "println",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro_rules! concat_bytes",          documentation = {            kind = "markdown",            value = "Concatenates literals into a byte slice.\n\nThis macro takes any number of comma-separated literals, and concatenates them all into\none, yielding an expression of type `&[u8, _]`, which represents all of the literals\nconcatenated left-to-right. The literals passed can be any combination of:\n\n- byte literals (`b'r'`)\n- byte strings (`b\"Rust\"`)\n- arrays of bytes/numbers (`[b'A', 66, b'C']`)\n\n# Examples\n\n```rust\n#![feature(concat_bytes)]\n\nlet s: &[u8; 6] = concat_bytes!(b'A', b\"BC\", [68, b'E', 70]);\nassert_eq!(s, b\"ABCDEF\");\n```"          },          filterText = "concat_bytes",          kind = 3,          label = "concat_bytes",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "concat_bytes",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro_rules! assert_eq",          documentation = {            kind = "markdown",            value = 'Asserts that two expressions are equal to each other (using [`PartialEq`]).\n\nOn panic, this macro will print the values of the expressions with their\ndebug representations.\n\nLike [`assert!`], this macro has a second form, where a custom\npanic message can be provided.\n\n# Examples\n\n```rust\nlet a = 3;\nlet b = 1 + 2;\nassert_eq!(a, b);\n\nassert_eq!(a, b, "we are testing addition with {} and {}", a, b);\n```'          },          filterText = "assert_eq",          kind = 3,          label = "assert_eq",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "assert_eq",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro_rules! is_x86_feature_detected",          documentation = {            kind = "markdown",            value = 'A macro to test at *runtime* whether a CPU feature is available on\nx86/x86-64 platforms.\n\nThis macro is provided in the standard library and will detect at runtime\nwhether the specified CPU feature is detected. This does **not** resolve at\ncompile time unless the specified feature is already enabled for the entire\ncrate. Runtime detection currently relies mostly on the `cpuid` instruction.\n\nThis macro only takes one argument which is a string literal of the feature\nbeing tested for. The feature names supported are the lowercase versions of\nthe ones defined by Intel in [their documentation][docs].\n\n## Supported arguments\n\nThis macro supports the same names that `#[target_feature]` supports. Unlike\n`#[target_feature]`, however, this macro does not support names separated\nwith a comma. Instead testing for multiple features must be done through\nseparate macro invocations for now.\n\nSupported arguments are:\n\n* `"aes"`\n* `"pclmulqdq"`\n* `"rdrand"`\n* `"rdseed"`\n* `"tsc"`\n* `"mmx"`\n* `"sse"`\n* `"sse2"`\n* `"sse3"`\n* `"ssse3"`\n* `"sse4.1"`\n* `"sse4.2"`\n* `"sse4a"`\n* `"sha"`\n* `"avx"`\n* `"avx2"`\n* `"avx512f"`\n* `"avx512cd"`\n* `"avx512er"`\n* `"avx512pf"`\n* `"avx512bw"`\n* `"avx512dq"`\n* `"avx512vl"`\n* `"avx512ifma"`\n* `"avx512vbmi"`\n* `"avx512vpopcntdq"`\n* `"avx512vbmi2"`\n* `"avx512gfni"`\n* `"avx512vaes"`\n* `"avx512vpclmulqdq"`\n* `"avx512vnni"`\n* `"avx512bitalg"`\n* `"avx512bf16"`\n* `"avx512vp2intersect"`\n* `"f16c"`\n* `"fma"`\n* `"bmi1"`\n* `"bmi2"`\n* `"abm"`\n* `"lzcnt"`\n* `"tbm"`\n* `"popcnt"`\n* `"fxsr"`\n* `"xsave"`\n* `"xsaveopt"`\n* `"xsaves"`\n* `"xsavec"`\n* `"cmpxchg16b"`\n* `"adx"`\n* `"rtm"`\n\n[docs]: https://software.intel.com/sites/landingpage/IntrinsicsGuide'          },          filterText = "is_x86_feature_detected",          kind = 3,          label = "is_x86_feature_detected",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "is_x86_feature_detected",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro_rules! format_args",          documentation = {            kind = "markdown",            value = 'Constructs parameters for the other string-formatting macros.\n\nThis macro functions by taking a formatting string literal containing\n`{}` for each additional argument passed. `format_args!` prepares the\nadditional parameters to ensure the output can be interpreted as a string\nand canonicalizes the arguments into a single type. Any value that implements\nthe [`Display`] trait can be passed to `format_args!`, as can any\n[`Debug`] implementation be passed to a `{:?}` within the formatting string.\n\nThis macro produces a value of type [`fmt::Arguments`]. This value can be\npassed to the macros within [`std::fmt`] for performing useful redirection.\nAll other formatting macros ([`format!`], [`write!`], [`println!`], etc) are\nproxied through this one. `format_args!`, unlike its derived macros, avoids\nheap allocations.\n\nYou can use the [`fmt::Arguments`] value that `format_args!` returns\nin `Debug` and `Display` contexts as seen below. The example also shows\nthat `Debug` and `Display` format to the same thing: the interpolated\nformat string in `format_args!`.\n\n```rust\nlet debug = format!("{:?}", format_args!("{} foo {:?}", 1, 2));\nlet display = format!("{}", format_args!("{} foo {:?}", 1, 2));\nassert_eq!("1 foo 2", display);\nassert_eq!(display, debug);\n```\n\nFor more information, see the documentation in [`std::fmt`].\n\n[`Display`]: crate::fmt::Display\n[`Debug`]: crate::fmt::Debug\n[`fmt::Arguments`]: crate::fmt::Arguments\n[`std::fmt`]: ../std/fmt/index.html\n[`format!`]: ../std/macro.format.html\n[`println!`]: ../std/macro.println.html\n\n# Examples\n\n```rust\nuse std::fmt;\n\nlet s = fmt::format(format_args!("hello {}", "world"));\nassert_eq!(s, format!("hello {}", "world"));\n```'          },          filterText = "format_args",          kind = 3,          label = "format_args",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "format_args",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "macro_rules! debug_assert_ne",          documentation = {            kind = "markdown",            value = "Asserts that two expressions are not equal to each other.\n\nOn panic, this macro will print the values of the expressions with their\ndebug representations.\n\nUnlike [`assert_ne!`], `debug_assert_ne!` statements are only enabled in non\noptimized builds by default. An optimized build will not execute\n`debug_assert_ne!` statements unless `-C debug-assertions` is passed to the\ncompiler. This makes `debug_assert_ne!` useful for checks that are too\nexpensive to be present in a release build but may be helpful during\ndevelopment. The result of expanding `debug_assert_ne!` is always type checked.\n\n# Examples\n\n```rust\nlet a = 3;\nlet b = 2;\ndebug_assert_ne!(a, b);\n```"          },          filterText = "debug_assert_ne",          kind = 3,          label = "debug_assert_ne",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "debug_assert_ne",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "# The Rust Standard Library\n\nThe Rust Standard Library is the foundation of portable Rust software, a\nset of minimal and battle-tested shared abstractions for the [broader Rust\necosystem][crates.io]. It offers core types, like [`Vec<T>`] and\n[`Option<T>`], library-defined [operations on language\nprimitives](#primitives), [standard macros](#macros), [I/O] and\n[multithreading], among [many other things][other].\n\n`std` is available to all Rust crates by default. Therefore, the\nstandard library can be accessed in [`use`] statements through the path\n`std`, as in [`use std::env`].\n\n# How to read this documentation\n\nIf you already know the name of what you are looking for, the fastest way to\nfind it is to use the <a href=\"#\" onclick=\"focusSearchBar();\">search\nbar</a> at the top of the page.\n\nOtherwise, you may want to jump to one of these useful sections:\n\n* [`std::*` modules](#modules)\n* [Primitive types](#primitives)\n* [Standard macros](#macros)\n* [The Rust Prelude]\n\nIf this is your first time, the documentation for the standard library is\nwritten to be casually perused. Clicking on interesting things should\ngenerally lead you to interesting places. Still, there are important bits\nyou don't want to miss, so read on for a tour of the standard library and\nits documentation!\n\nOnce you are familiar with the contents of the standard library you may\nbegin to find the verbosity of the prose distracting. At this stage in your\ndevelopment you may want to press the `[-]` button near the top of the\npage to collapse it into a more skimmable view.\n\nWhile you are looking at that `[-]` button also notice the `source`\nlink. Rust's API documentation comes with the source code and you are\nencouraged to read it. The standard library source is generally high\nquality and a peek behind the curtains is often enlightening.\n\n# What is in the standard library documentation?\n\nFirst of all, The Rust Standard Library is divided into a number of focused\nmodules, [all listed further down this page](#modules). These modules are\nthe bedrock upon which all of Rust is forged, and they have mighty names\nlike [`std::slice`] and [`std::cmp`]. Modules' documentation typically\nincludes an overview of the module along with examples, and are a smart\nplace to start familiarizing yourself with the library.\n\nSecond, implicit methods on [primitive types] are documented here. This can\nbe a source of confusion for two reasons:\n\n1. While primitives are implemented by the compiler, the standard library\n   implements methods directly on the primitive types (and it is the only\n   library that does so), which are [documented in the section on\n   primitives](#primitives).\n2. The standard library exports many modules *with the same name as\n   primitive types*. These define additional items related to the primitive\n   type, but not the all-important methods.\n\nSo for example there is a [page for the primitive type\n`i32`](primitive::i32) that lists all the methods that can be called on\n32-bit integers (very useful), and there is a [page for the module\n`std::i32`] that documents the constant values [`MIN`] and [`MAX`] (rarely\nuseful).\n\nNote the documentation for the primitives [`str`] and [`[T]`][prim@slice] (also\ncalled 'slice'). Many method calls on [`String`] and [`Vec<T>`] are actually\ncalls to methods on [`str`] and [`[T]`][prim@slice] respectively, via [deref\ncoercions][deref-coercions].\n\nThird, the standard library defines [The Rust Prelude], a small collection\nof items - mostly traits - that are imported into every module of every\ncrate. The traits in the prelude are pervasive, making the prelude\ndocumentation a good entry point to learning about the library.\n\nAnd finally, the standard library exports a number of standard macros, and\n[lists them on this page](#macros) (technically, not all of the standard\nmacros are defined by the standard library - some are defined by the\ncompiler - but they are documented here the same). Like the prelude, the\nstandard macros are imported by default into all crates.\n\n# Contributing changes to the documentation\n\nCheck out the rust contribution guidelines [here](\nhttps://rustc-dev-guide.rust-lang.org/contributing.html#writing-documentation).\nThe source for this documentation can be found on\n[GitHub](https://github.com/rust-lang/rust).\nTo contribute changes, make sure you read the guidelines first, then submit\npull-requests for your suggested changes.\n\nContributions are appreciated! If you see a part of the docs that can be\nimproved, submit a PR, or chat with us first on [Discord][rust-discord]\n#docs.\n\n# A Tour of The Rust Standard Library\n\nThe rest of this crate documentation is dedicated to pointing out notable\nfeatures of The Rust Standard Library.\n\n## Containers and collections\n\nThe [`option`] and [`result`] modules define optional and error-handling\ntypes, [`Option<T>`] and [`Result<T, E>`]. The [`iter`] module defines\nRust's iterator trait, [`Iterator`], which works with the [`for`] loop to\naccess collections.\n\nThe standard library exposes three common ways to deal with contiguous\nregions of memory:\n\n* [`Vec<T>`] - A heap-allocated *vector* that is resizable at runtime.\n* [`[T; N]`][prim@array] - An inline *array* with a fixed size at compile time.\n* [`[T]`][prim@slice] - A dynamically sized *slice* into any other kind of contiguous\n  storage, whether heap-allocated or not.\n\nSlices can only be handled through some kind of *pointer*, and as such come\nin many flavors such as:\n\n* `&[T]` - *shared slice*\n* `&mut [T]` - *mutable slice*\n* [`Box<[T]>`][owned slice] - *owned slice*\n\n[`str`], a UTF-8 string slice, is a primitive type, and the standard library\ndefines many methods for it. Rust [`str`]s are typically accessed as\nimmutable references: `&str`. Use the owned [`String`] for building and\nmutating strings.\n\nFor converting to strings use the [`format!`] macro, and for converting from\nstrings use the [`FromStr`] trait.\n\nData may be shared by placing it in a reference-counted box or the [`Rc`]\ntype, and if further contained in a [`Cell`] or [`RefCell`], may be mutated\nas well as shared. Likewise, in a concurrent setting it is common to pair an\natomically-reference-counted box, [`Arc`], with a [`Mutex`] to get the same\neffect.\n\nThe [`collections`] module defines maps, sets, linked lists and other\ntypical collection types, including the common [`HashMap<K, V>`].\n\n## Platform abstractions and I/O\n\nBesides basic data types, the standard library is largely concerned with\nabstracting over differences in common platforms, most notably Windows and\nUnix derivatives.\n\nCommon types of I/O, including [files], [TCP], [UDP], are defined in the\n[`io`], [`fs`], and [`net`] modules.\n\nThe [`thread`] module contains Rust's threading abstractions. [`sync`]\ncontains further primitive shared memory types, including [`atomic`] and\n[`mpsc`], which contains the channel types for message passing.\n\n[I/O]: io\n[`MIN`]: i32::MIN\n[`MAX`]: i32::MAX\n[page for the module `std::i32`]: crate::i32\n[TCP]: net::TcpStream\n[The Rust Prelude]: prelude\n[UDP]: net::UdpSocket\n[`Arc`]: sync::Arc\n[owned slice]: boxed\n[`Cell`]: cell::Cell\n[`FromStr`]: str::FromStr\n[`HashMap<K, V>`]: collections::HashMap\n[`Mutex`]: sync::Mutex\n[`Option<T>`]: option::Option\n[`Rc`]: rc::Rc\n[`RefCell`]: cell::RefCell\n[`Result<T, E>`]: result::Result\n[`Vec<T>`]: vec::Vec\n[`atomic`]: sync::atomic\n[`for`]: ../book/ch03-05-control-flow.html#looping-through-a-collection-with-for\n[`str`]: prim@str\n[`mpsc`]: sync::mpsc\n[`std::cmp`]: cmp\n[`std::slice`]: mod@slice\n[`use std::env`]: env/index.html\n[`use`]: ../book/ch07-02-defining-modules-to-control-scope-and-privacy.html\n[crates.io]: https://crates.io\n[deref-coercions]: ../book/ch15-02-deref.html#implicit-deref-coercions-with-functions-and-methods\n[files]: fs::File\n[multithreading]: thread\n[other]: #what-is-in-the-standard-library-documentation\n[primitive types]: ../book/ch03-02-data-types.html\n[rust-discord]: https://discord.gg/rust-lang\n[array]: prim@array\n[slice]: prim@slice"          },          filterText = "std",          kind = 9,          label = "std",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "std",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "# The Rust core allocation and collections library\n\nThis library provides smart pointers and collections for managing\nheap-allocated values.\n\nThis library, like libcore, normally doesn’t need to be used directly\nsince its contents are re-exported in the [`std` crate](../std/index.html).\nCrates that use the `#![no_std]` attribute however will typically\nnot depend on `std`, so they’d use this crate instead.\n\n## Boxed values\n\nThe [`Box`] type is a smart pointer type. There can only be one owner of a\n[`Box`], and the owner can decide to mutate the contents, which live on the\nheap.\n\nThis type can be sent among threads efficiently as the size of a `Box` value\nis the same as that of a pointer. Tree-like data structures are often built\nwith boxes because each node often has only one owner, the parent.\n\n## Reference counted pointers\n\nThe [`Rc`] type is a non-threadsafe reference-counted pointer type intended\nfor sharing memory within a thread. An [`Rc`] pointer wraps a type, `T`, and\nonly allows access to `&T`, a shared reference.\n\nThis type is useful when inherited mutability (such as using [`Box`]) is too\nconstraining for an application, and is often paired with the [`Cell`] or\n[`RefCell`] types in order to allow mutation.\n\n## Atomically reference counted pointers\n\nThe [`Arc`] type is the threadsafe equivalent of the [`Rc`] type. It\nprovides all the same functionality of [`Rc`], except it requires that the\ncontained type `T` is shareable. Additionally, [`Arc<T>`][`Arc`] is itself\nsendable while [`Rc<T>`][`Rc`] is not.\n\nThis type allows for shared access to the contained data, and is often\npaired with synchronization primitives such as mutexes to allow mutation of\nshared resources.\n\n## Collections\n\nImplementations of the most common general purpose data structures are\ndefined in this library. They are re-exported through the\n[standard collections library](../std/collections/index.html).\n\n## Heap interfaces\n\nThe [`alloc`](alloc/index.html) module defines the low-level interface to the\ndefault global allocator. It is not compatible with the libc allocator API.\n\n[`Arc`]: sync\n[`Box`]: boxed\n[`Cell`]: core::cell\n[`Rc`]: rc\n[`RefCell`]: core::cell"          },          filterText = "alloc",          kind = 9,          label = "alloc",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "alloc",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "Factorio lib\n\nThis library provides an interface to Factorio data types, mod prototypes and Web API.\nCheck the individual module documentation for details\n\nModules are gated behind features with corresponding names, which are all enabled by default."          },          filterText = "factorio_lib_rs",          kind = 9,          label = "factorio_lib_rs",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "factorio_lib_rs",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "`x-www-form-urlencoded` meets Serde"          },          filterText = "serde_urlencoded",          kind = 9,          label = "serde_urlencoded",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "serde_urlencoded",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "# reqwest\n\nThe `reqwest` crate provides a convenient, higher-level HTTP\n[`Client`][client].\n\nIt handles many of the things that most people just expect an HTTP client\nto do for them.\n\n- Async and [blocking](blocking) Clients\n- Plain bodies, [JSON](#json), [urlencoded](#forms), [multipart](multipart)\n- Customizable [redirect policy](#redirect-policies)\n- HTTP [Proxies](#proxies)\n- Uses system-native [TLS](#tls)\n- Cookies\n\nThe [`reqwest::Client`][client] is asynchronous. For applications wishing\nto only make a few HTTP requests, the [`reqwest::blocking`](blocking) API\nmay be more convenient.\n\nAdditional learning resources include:\n\n- [The Rust Cookbook](https://rust-lang-nursery.github.io/rust-cookbook/web/clients.html)\n- [Reqwest Repository Examples](https://github.com/seanmonstar/reqwest/tree/master/examples)\n\n## Making a GET request\n\nFor a single request, you can use the [`get`][get] shortcut method.\n\n```rust\nlet body = reqwest::get(\"https://www.rust-lang.org\")\n    .await?\n    .text()\n    .await?;\n\nprintln!(\"body = {:?}\", body);\n```\n\n**NOTE**: If you plan to perform multiple requests, it is best to create a\n[`Client`][client] and reuse it, taking advantage of keep-alive connection\npooling.\n\n## Making POST requests (or setting request bodies)\n\nThere are several ways you can set the body of a request. The basic one is\nby using the `body()` method of a [`RequestBuilder`][builder]. This lets you set the\nexact raw bytes of what the body should be. It accepts various types,\nincluding `String` and `Vec<u8>`. If you wish to pass a custom\ntype, you can use the `reqwest::Body` constructors.\n\n```rust\nlet client = reqwest::Client::new();\nlet res = client.post(\"http://httpbin.org/post\")\n    .body(\"the exact body that is sent\")\n    .send()\n    .await?;\n```\n\n### Forms\n\nIt's very common to want to send form data in a request body. This can be\ndone with any type that can be serialized into form data.\n\nThis can be an array of tuples, or a `HashMap`, or a custom type that\nimplements [`Serialize`][serde].\n\n```rust\n// This will POST a body of `foo=bar&baz=quux`\nlet params = [(\"foo\", \"bar\"), (\"baz\", \"quux\")];\nlet client = reqwest::Client::new();\nlet res = client.post(\"http://httpbin.org/post\")\n    .form(&params)\n    .send()\n    .await?;\n```\n\n### JSON\n\nThere is also a `json` method helper on the [`RequestBuilder`][builder] that works in\na similar fashion the `form` method. It can take any value that can be\nserialized into JSON. The feature `json` is required.\n\n```rust\n// This will POST a body of `{\"lang\":\"rust\",\"body\":\"json\"}`\nlet mut map = HashMap::new();\nmap.insert(\"lang\", \"rust\");\nmap.insert(\"body\", \"json\");\n\nlet client = reqwest::Client::new();\nlet res = client.post(\"http://httpbin.org/post\")\n    .json(&map)\n    .send()\n    .await?;\n```\n\n## Redirect Policies\n\nBy default, a `Client` will automatically handle HTTP redirects, having a\nmaximum redirect chain of 10 hops. To customize this behavior, a\n[`redirect::Policy`][redirect] can be used with a `ClientBuilder`.\n\n## Cookies\n\nThe automatic storing and sending of session cookies can be enabled with\nthe [`cookie_store`][ClientBuilder::cookie_store] method on `ClientBuilder`.\n\n## Proxies\n\n**NOTE**: System proxies are enabled by default.\n\nSystem proxies look in environment variables to set HTTP or HTTPS proxies.\n\n`HTTP_PROXY` or `http_proxy` provide http proxies for http connections while\n`HTTPS_PROXY` or `https_proxy` provide HTTPS proxies for HTTPS connections.\n\nThese can be overwritten by adding a [`Proxy`](Proxy) to `ClientBuilder`\ni.e. `let proxy = reqwest::Proxy::http(\"https://secure.example\")?;`\nor disabled by calling `ClientBuilder::no_proxy()`.\n\n`socks` feature is required if you have configured socks proxy like this:\n\n```bash\nexport https_proxy=socks5://127.0.0.1:1086\n```\n\n## TLS\n\nBy default, a `Client` will make use of system-native transport layer\nsecurity to connect to HTTPS destinations. This means schannel on Windows,\nSecurity-Framework on macOS, and OpenSSL on Linux.\n\n- Additional X509 certificates can be configured on a `ClientBuilder` with the\n  [`Certificate`](Certificate) type.\n- Client certificates can be add to a `ClientBuilder` with the\n  [`Identity`][Identity] type.\n- Various parts of TLS can also be configured or even disabled on the\n  `ClientBuilder`.\n\n## Optional Features\n\nThe following are a list of [Cargo features][cargo-features] that can be\nenabled or disabled:\n\n- **default-tls** *(enabled by default)*: Provides TLS support to connect\n  over HTTPS.\n- **native-tls**: Enables TLS functionality provided by `native-tls`.\n- **native-tls-vendored**: Enables the `vendored` feature of `native-tls`.\n- **native-tls-alpn**: Enables the `alpn` feature of `native-tls`.\n- **rustls-tls**: Enables TLS functionality provided by `rustls`.\n  Equivalent to `rustls-tls-webpki-roots`.\n- **rustls-tls-manual-roots**: Enables TLS functionality provided by `rustls`,\n  without setting any root certificates. Roots have to be specified manually.\n- **rustls-tls-webpki-roots**: Enables TLS functionality provided by `rustls`,\n  while using root certificates from the `webpki-roots` crate.\n- **rustls-tls-native-roots**: Enables TLS functionality provided by `rustls`,\n  while using root certificates from the `rustls-native-certs` crate.\n- **blocking**: Provides the [blocking][] client API.\n- **cookies**: Provides cookie session support.\n- **gzip**: Provides response body gzip decompression.\n- **brotli**: Provides response body brotli decompression.\n- **deflate**: Provides response body deflate decompression.\n- **json**: Provides serialization and deserialization for JSON bodies.\n- **multipart**: Provides functionality for multipart forms.\n- **stream**: Adds support for `futures::Stream`.\n- **socks**: Provides SOCKS5 proxy support.\n- **trust-dns**: Enables a trust-dns async resolver instead of default\n  threadpool using `getaddrinfo`.\n\n\n[hyper]: http://hyper.rs\n[blocking]: ./blocking/index.html\n[client]: ./struct.Client.html\n[response]: ./struct.Response.html\n[get]: ./fn.get.html\n[builder]: ./struct.RequestBuilder.html\n[serde]: http://serde.rs\n[redirect]: crate::redirect\n[Proxy]: ./struct.Proxy.html\n[cargo-features]: https://doc.rust-lang.org/stable/cargo/reference/manifest.html#the-features-section"          },          filterText = "reqwest",          kind = 9,          label = "reqwest",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "reqwest",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "# The Rust Core Library\n\nThe Rust Core Library is the dependency-free[^free] foundation of [The\nRust Standard Library](../std/index.html). It is the portable glue\nbetween the language and its libraries, defining the intrinsic and\nprimitive building blocks of all Rust code. It links to no\nupstream libraries, no system libraries, and no libc.\n\n[^free]: Strictly speaking, there are some symbols which are needed but\n         they aren't always necessary.\n\nThe core library is *minimal*: it isn't even aware of heap allocation,\nnor does it provide concurrency or I/O. These things require\nplatform integration, and this library is platform-agnostic.\n\n# How to use the core library\n\nPlease note that all of these details are currently not considered stable.\n\nThis library is built on the assumption of a few existing symbols:\n\n* `memcpy`, `memcmp`, `memset` - These are core memory routines which are\n  often generated by LLVM. Additionally, this library can make explicit\n  calls to these functions. Their signatures are the same as found in C.\n  These functions are often provided by the system libc, but can also be\n  provided by the [compiler-builtins crate](https://crates.io/crates/compiler_builtins).\n\n* `rust_begin_panic` - This function takes four arguments, a\n  `fmt::Arguments`, a `&'static str`, and two `u32`'s. These four arguments\n  dictate the panic message, the file at which panic was invoked, and the\n  line and column inside the file. It is up to consumers of this core\n  library to define this panic function; it is only required to never\n  return. This requires a `lang` attribute named `panic_impl`.\n\n* `rust_eh_personality` - is used by the failure mechanisms of the\n   compiler. This is often mapped to GCC's personality function, but crates\n   which do not trigger a panic can be assured that this function is never\n   called. The `lang` attribute is called `eh_personality`."          },          filterText = "core",          kind = 9,          label = "core",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "core",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "A runtime for writing reliable network applications without compromising speed.\n\nTokio is an event-driven, non-blocking I/O platform for writing asynchronous\napplications with the Rust programming language. At a high level, it\nprovides a few major components:\n\n* Tools for [working with asynchronous tasks][tasks], including\n  [synchronization primitives and channels][sync] and [timeouts, sleeps, and\n  intervals][time].\n* APIs for [performing asynchronous I/O][io], including [TCP and UDP][net] sockets,\n  [filesystem][fs] operations, and [process] and [signal] management.\n* A [runtime] for executing asynchronous code, including a task scheduler,\n  an I/O driver backed by the operating system's event queue (epoll, kqueue,\n  IOCP, etc...), and a high performance timer.\n\nGuide level documentation is found on the [website].\n\n[tasks]: #working-with-tasks\n[sync]: crate::sync\n[time]: crate::time\n[io]: #asynchronous-io\n[net]: crate::net\n[fs]: crate::fs\n[process]: crate::process\n[signal]: crate::signal\n[fs]: crate::fs\n[runtime]: crate::runtime\n[website]: https://tokio.rs/tokio/tutorial\n\n# A Tour of Tokio\n\nTokio consists of a number of modules that provide a range of functionality\nessential for implementing asynchronous applications in Rust. In this\nsection, we will take a brief tour of Tokio, summarizing the major APIs and\ntheir uses.\n\nThe easiest way to get started is to enable all features. Do this by\nenabling the `full` feature flag:\n\n```toml\ntokio = { version = \"1\", features = [\"full\"] }\n```\n\n### Authoring applications\n\nTokio is great for writing applications and most users in this case shouldn't\nworry too much about what features they should pick. If you're unsure, we suggest\ngoing with `full` to ensure that you don't run into any road blocks while you're\nbuilding your application.\n\n#### Example\n\nThis example shows the quickest way to get started with Tokio.\n\n```toml\ntokio = { version = \"1\", features = [\"full\"] }\n```\n\n### Authoring libraries\n\nAs a library author your goal should be to provide the lightest weight crate\nthat is based on Tokio. To achieve this you should ensure that you only enable\nthe features you need. This allows users to pick up your crate without having\nto enable unnecessary features.\n\n#### Example\n\nThis example shows how you may want to import features for a library that just\nneeds to `tokio::spawn` and use a `TcpStream`.\n\n```toml\ntokio = { version = \"1\", features = [\"rt\", \"net\"] }\n```\n\n## Working With Tasks\n\nAsynchronous programs in Rust are based around lightweight, non-blocking\nunits of execution called [_tasks_][tasks]. The [`tokio::task`] module provides\nimportant tools for working with tasks:\n\n* The [`spawn`] function and [`JoinHandle`] type, for scheduling a new task\n  on the Tokio runtime and awaiting the output of a spawned task, respectively,\n* Functions for [running blocking operations][blocking] in an asynchronous\n  task context.\n\nThe [`tokio::task`] module is present only when the \"rt\" feature flag\nis enabled.\n\n[tasks]: task/index.html#what-are-tasks\n[`tokio::task`]: crate::task\n[`spawn`]: crate::task::spawn()\n[`JoinHandle`]: crate::task::JoinHandle\n[blocking]: task/index.html#blocking-and-yielding\n\nThe [`tokio::sync`] module contains synchronization primitives to use when\nneeding to communicate or share data. These include:\n\n* channels ([`oneshot`], [`mpsc`], and [`watch`]), for sending values\n  between tasks,\n* a non-blocking [`Mutex`], for controlling access to a shared, mutable\n  value,\n* an asynchronous [`Barrier`] type, for multiple tasks to synchronize before\n  beginning a computation.\n\nThe `tokio::sync` module is present only when the \"sync\" feature flag is\nenabled.\n\n[`tokio::sync`]: crate::sync\n[`Mutex`]: crate::sync::Mutex\n[`Barrier`]: crate::sync::Barrier\n[`oneshot`]: crate::sync::oneshot\n[`mpsc`]: crate::sync::mpsc\n[`watch`]: crate::sync::watch\n\nThe [`tokio::time`] module provides utilities for tracking time and\nscheduling work. This includes functions for setting [timeouts][timeout] for\ntasks, [sleeping][sleep] work to run in the future, or [repeating an operation at an\ninterval][interval].\n\nIn order to use `tokio::time`, the \"time\" feature flag must be enabled.\n\n[`tokio::time`]: crate::time\n[sleep]: crate::time::sleep()\n[interval]: crate::time::interval()\n[timeout]: crate::time::timeout()\n\nFinally, Tokio provides a _runtime_ for executing asynchronous tasks. Most\napplications can use the [`#[tokio::main]`][main] macro to run their code on the\nTokio runtime. However, this macro provides only basic configuration options. As\nan alternative, the [`tokio::runtime`] module provides more powerful APIs for configuring\nand managing runtimes. You should use that module if the `#[tokio::main]` macro doesn't\nprovide the functionality you need.\n\nUsing the runtime requires the \"rt\" or \"rt-multi-thread\" feature flags, to\nenable the basic [single-threaded scheduler][rt] and the [thread-pool\nscheduler][rt-multi-thread], respectively. See the [`runtime` module\ndocumentation][rt-features] for details. In addition, the \"macros\" feature\nflag enables the `#[tokio::main]` and `#[tokio::test]` attributes.\n\n[main]: attr.main.html\n[`tokio::runtime`]: crate::runtime\n[`Builder`]: crate::runtime::Builder\n[`Runtime`]: crate::runtime::Runtime\n[rt]: runtime/index.html#current-thread-scheduler\n[rt-multi-thread]: runtime/index.html#multi-thread-scheduler\n[rt-features]: runtime/index.html#runtime-scheduler\n\n## CPU-bound tasks and blocking code\n\nTokio is able to concurrently run many tasks on a few threads by repeatedly\nswapping the currently running task on each thread. However, this kind of\nswapping can only happen at `.await` points, so code that spends a long time\nwithout reaching an `.await` will prevent other tasks from running. To\ncombat this, Tokio provides two kinds of threads: Core threads and blocking\nthreads. The core threads are where all asynchronous code runs, and Tokio\nwill by default spawn one for each CPU core. The blocking threads are\nspawned on demand, can be used to run blocking code that would otherwise\nblock other tasks from running and are kept alive when not used for a certain\namount of time which can be configured with [`thread_keep_alive`].\nSince it is not possible for Tokio to swap out blocking tasks, like it\ncan do with asynchronous code, the upper limit on the number of blocking\nthreads is very large. These limits can be configured on the [`Builder`].\n\nTo spawn a blocking task, you should use the [`spawn_blocking`] function.\n\n[`Builder`]: crate::runtime::Builder\n[`spawn_blocking`]: crate::task::spawn_blocking()\n[`thread_keep_alive`]: crate::runtime::Builder::thread_keep_alive()\n\n```rust\n#[tokio::main]\nasync fn main() {\n    // This is running on a core thread.\n\n    let blocking_task = tokio::task::spawn_blocking(|| {\n        // This is running on a blocking thread.\n        // Blocking here is ok.\n    });\n\n    // We can wait for the blocking task like this:\n    // If the blocking task panics, the unwrap below will propagate the\n    // panic.\n    blocking_task.await.unwrap();\n}\n```\n\nIf your code is CPU-bound and you wish to limit the number of threads used\nto run it, you should use a separate thread pool dedicated to CPU bound tasks.\nFor example, you could consider using the [rayon] library for CPU-bound\ntasks. It is also possible to create an extra Tokio runtime dedicated to\nCPU-bound tasks, but if you do this, you should be careful that the extra\nruntime runs _only_ CPU-bound tasks, as IO-bound tasks on that runtime\nwill behave poorly.\n\nHint: If using rayon, you can use a [`oneshot`] channel to send the result back\nto Tokio when the rayon task finishes.\n\n[rayon]: https://docs.rs/rayon\n[`oneshot`]: crate::sync::oneshot\n\n## Asynchronous IO\n\nAs well as scheduling and running tasks, Tokio provides everything you need\nto perform input and output asynchronously.\n\nThe [`tokio::io`] module provides Tokio's asynchronous core I/O primitives,\nthe [`AsyncRead`], [`AsyncWrite`], and [`AsyncBufRead`] traits. In addition,\nwhen the \"io-util\" feature flag is enabled, it also provides combinators and\nfunctions for working with these traits, forming as an asynchronous\ncounterpart to [`std::io`].\n\nTokio also includes APIs for performing various kinds of I/O and interacting\nwith the operating system asynchronously. These include:\n\n* [`tokio::net`], which contains non-blocking versions of [TCP], [UDP], and\n  [Unix Domain Sockets][UDS] (enabled by the \"net\" feature flag),\n* [`tokio::fs`], similar to [`std::fs`] but for performing filesystem I/O\n  asynchronously (enabled by the \"fs\" feature flag),\n* [`tokio::signal`], for asynchronously handling Unix and Windows OS signals\n  (enabled by the \"signal\" feature flag),\n* [`tokio::process`], for spawning and managing child processes (enabled by\n  the \"process\" feature flag).\n\n[`tokio::io`]: crate::io\n[`AsyncRead`]: crate::io::AsyncRead\n[`AsyncWrite`]: crate::io::AsyncWrite\n[`AsyncBufRead`]: crate::io::AsyncBufRead\n[`std::io`]: std::io\n[`tokio::net`]: crate::net\n[TCP]: crate::net::tcp\n[UDP]: crate::net::UdpSocket\n[UDS]: crate::net::unix\n[`tokio::fs`]: crate::fs\n[`std::fs`]: std::fs\n[`tokio::signal`]: crate::signal\n[`tokio::process`]: crate::process\n\n# Examples\n\nA simple TCP echo server:\n\n```rust\nuse tokio::net::TcpListener;\nuse tokio::io::{AsyncReadExt, AsyncWriteExt};\n\n#[tokio::main]\nasync fn main() -> Result<(), Box<dyn std::error::Error>> {\n    let listener = TcpListener::bind(\"127.0.0.1:8080\").await?;\n\n    loop {\n        let (mut socket, _) = listener.accept().await?;\n\n        tokio::spawn(async move {\n            let mut buf = [0; 1024];\n\n            // In a loop, read data from the socket and write the data back.\n            loop {\n                let n = match socket.read(&mut buf).await {\n                    // socket closed\n                    Ok(n) if n == 0 => return,\n                    Ok(n) => n,\n                    Err(e) => {\n                        eprintln!(\"failed to read from socket; err = {:?}\", e);\n                        return;\n                    }\n                };\n\n                // Write the data back\n                if let Err(e) = socket.write_all(&buf[0..n]).await {\n                    eprintln!(\"failed to write to socket; err = {:?}\", e);\n                    return;\n                }\n            }\n        });\n    }\n}\n```\n\n## Feature flags\n\nTokio uses a set of [feature flags] to reduce the amount of compiled code. It\nis possible to just enable certain features over others. By default, Tokio\ndoes not enable any features but allows one to enable a subset for their use\ncase. Below is a list of the available feature flags. You may also notice\nabove each function, struct and trait there is listed one or more feature flags\nthat are required for that item to be used. If you are new to Tokio it is\nrecommended that you use the `full` feature flag which will enable all public APIs.\nBeware though that this will pull in many extra dependencies that you may not\nneed.\n\n- `full`: Enables all features listed below except `test-util` and `tracing`.\n- `rt`: Enables `tokio::spawn`, the basic (current thread) scheduler,\n        and non-scheduler utilities.\n- `rt-multi-thread`: Enables the heavier, multi-threaded, work-stealing scheduler.\n- `io-util`: Enables the IO based `Ext` traits.\n- `io-std`: Enable `Stdout`, `Stdin` and `Stderr` types.\n- `net`: Enables `tokio::net` types such as `TcpStream`, `UnixStream` and\n         `UdpSocket`, as well as (on Unix-like systems) `AsyncFd` and (on\n         FreeBSD) `PollAio`.\n- `time`: Enables `tokio::time` types and allows the schedulers to enable\n          the built in timer.\n- `process`: Enables `tokio::process` types.\n- `macros`: Enables `#[tokio::main]` and `#[tokio::test]` macros.\n- `sync`: Enables all `tokio::sync` types.\n- `signal`: Enables all `tokio::signal` types.\n- `fs`: Enables `tokio::fs` types.\n- `test-util`: Enables testing based infrastructure for the Tokio runtime.\n\n_Note: `AsyncRead` and `AsyncWrite` traits do not require any features and are\nalways available._\n\n### Internal features\n\nThese features do not expose any new API, but influence internal\nimplementation aspects of Tokio, and can pull in additional\ndependencies.\n\n- `parking_lot`: As a potential optimization, use the _parking_lot_ crate's\nsynchronization primitives internally. MSRV may increase according to the\n_parking_lot_ release in use.\n\n### Unstable features\n\nThese feature flags enable **unstable** features. The public API may break in 1.x\nreleases. To enable these features, the `--cfg tokio_unstable` must be passed to\n`rustc` when compiling. This is easiest done using the `RUSTFLAGS` env variable:\n`RUSTFLAGS=\"--cfg tokio_unstable\"`.\n\n- `tracing`: Enables tracing events.\n\n[feature flags]: https://doc.rust-lang.org/cargo/reference/manifest.html#the-features-section"          },          filterText = "tokio",          kind = 9,          label = "tokio",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "tokio",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "# Serde\n\nSerde is a framework for ***ser***ializing and ***de***serializing Rust data\nstructures efficiently and generically.\n\nThe Serde ecosystem consists of data structures that know how to serialize\nand deserialize themselves along with data formats that know how to\nserialize and deserialize other things. Serde provides the layer by which\nthese two groups interact with each other, allowing any supported data\nstructure to be serialized and deserialized using any supported data format.\n\nSee the Serde website <https://serde.rs/> for additional documentation and\nusage examples.\n\n## Design\n\nWhere many other languages rely on runtime reflection for serializing data,\nSerde is instead built on Rust's powerful trait system. A data structure\nthat knows how to serialize and deserialize itself is one that implements\nSerde's `Serialize` and `Deserialize` traits (or uses Serde's derive\nattribute to automatically generate implementations at compile time). This\navoids any overhead of reflection or runtime type information. In fact in\nmany situations the interaction between data structure and data format can\nbe completely optimized away by the Rust compiler, leaving Serde\nserialization to perform the same speed as a handwritten serializer for the\nspecific selection of data structure and data format.\n\n## Data formats\n\nThe following is a partial list of data formats that have been implemented\nfor Serde by the community.\n\n- [JSON], the ubiquitous JavaScript Object Notation used by many HTTP APIs.\n- [Bincode], a compact binary format\n  used for IPC within the Servo rendering engine.\n- [CBOR], a Concise Binary Object Representation designed for small message\n  size without the need for version negotiation.\n- [YAML], a self-proclaimed human-friendly configuration language that ain't\n  markup language.\n- [MessagePack], an efficient binary format that resembles a compact JSON.\n- [TOML], a minimal configuration format used by [Cargo].\n- [Pickle], a format common in the Python world.\n- [RON], a Rusty Object Notation.\n- [BSON], the data storage and network transfer format used by MongoDB.\n- [Avro], a binary format used within Apache Hadoop, with support for schema\n  definition.\n- [JSON5], a superset of JSON including some productions from ES5.\n- [Postcard], a no\\_std and embedded-systems friendly compact binary format.\n- [URL] query strings, in the x-www-form-urlencoded format.\n- [Envy], a way to deserialize environment variables into Rust structs.\n  *(deserialization only)*\n- [Envy Store], a way to deserialize [AWS Parameter Store] parameters into\n  Rust structs. *(deserialization only)*\n- [S-expressions], the textual representation of code and data used by the\n  Lisp language family.\n- [D-Bus]'s binary wire format.\n- [FlexBuffers], the schemaless cousin of Google's FlatBuffers zero-copy serialization format.\n- [DynamoDB Items], the format used by [rusoto_dynamodb] to transfer data to\n  and from DynamoDB.\n\n[JSON]: https://github.com/serde-rs/json\n[Bincode]: https://github.com/servo/bincode\n[CBOR]: https://github.com/enarx/ciborium\n[YAML]: https://github.com/dtolnay/serde-yaml\n[MessagePack]: https://github.com/3Hren/msgpack-rust\n[TOML]: https://github.com/alexcrichton/toml-rs\n[Pickle]: https://github.com/birkenfeld/serde-pickle\n[RON]: https://github.com/ron-rs/ron\n[BSON]: https://github.com/zonyitoo/bson-rs\n[Avro]: https://github.com/flavray/avro-rs\n[JSON5]: https://github.com/callum-oakley/json5-rs\n[Postcard]: https://github.com/jamesmunns/postcard\n[URL]: https://docs.rs/serde_qs\n[Envy]: https://github.com/softprops/envy\n[Envy Store]: https://github.com/softprops/envy-store\n[Cargo]: https://doc.rust-lang.org/cargo/reference/manifest.html\n[AWS Parameter Store]: https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-paramstore.html\n[S-expressions]: https://github.com/rotty/lexpr-rs\n[D-Bus]: https://docs.rs/zvariant\n[FlexBuffers]: https://github.com/google/flatbuffers/tree/master/rust/flexbuffers\n[DynamoDB Items]: https://docs.rs/serde_dynamo\n[rusoto_dynamodb]: https://docs.rs/rusoto_dynamodb"          },          filterText = "serde",          kind = 9,          label = "serde",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "serde",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "Used to do a cheap mutable-to-mutable reference conversion.\n\nThis trait is similar to [`AsRef`] but used for converting between mutable\nreferences. If you need to do a costly conversion it is better to\nimplement [`From`] with type `&mut T` or write a custom function.\n\n**Note: This trait must not fail**. If the conversion can fail, use a\ndedicated method which returns an [`Option<T>`] or a [`Result<T, E>`].\n\n# Generic Implementations\n\n- `AsMut` auto-dereferences if the inner type is a mutable reference\n  (e.g.: `foo.as_mut()` will work the same if `foo` has type `&mut Foo`\n  or `&mut &mut Foo`)\n\n# Examples\n\nUsing `AsMut` as trait bound for a generic function we can accept all mutable references\nthat can be converted to type `&mut T`. Because [`Box<T>`] implements `AsMut<T>` we can\nwrite a function `add_one` that takes all arguments that can be converted to `&mut u64`.\nBecause [`Box<T>`] implements `AsMut<T>`, `add_one` accepts arguments of type\n`&mut Box<u64>` as well:\n\n```rust\nfn add_one<T: AsMut<u64>>(num: &mut T) {\n    *num.as_mut() += 1;\n}\n\nlet mut boxed_num = Box::new(0);\nadd_one(&mut boxed_num);\nassert_eq!(*boxed_num, 1);\n```\n\n[`Box<T>`]: ../../std/boxed/struct.Box.html"          },          filterText = "AsMut",          kind = 8,          label = "AsMut",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "AsMut",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "RustcDecodable",          kind = 18,          label = "RustcDecodable",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "RustcDecodable",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "Used to do value-to-value conversions while consuming the input value. It is the reciprocal of\n[`Into`].\n\nOne should always prefer implementing `From` over [`Into`]\nbecause implementing `From` automatically provides one with an implementation of [`Into`]\nthanks to the blanket implementation in the standard library.\n\nOnly implement [`Into`] when targeting a version prior to Rust 1.41 and converting to a type\noutside the current crate.\n`From` was not able to do these types of conversions in earlier versions because of Rust's\norphaning rules.\nSee [`Into`] for more details.\n\nPrefer using [`Into`] over using `From` when specifying trait bounds on a generic function.\nThis way, types that directly implement [`Into`] can be used as arguments as well.\n\nThe `From` is also very useful when performing error handling. When constructing a function\nthat is capable of failing, the return type will generally be of the form `Result<T, E>`.\nThe `From` trait simplifies error handling by allowing a function to return a single error type\nthat encapsulate multiple error types. See the \"Examples\" section and [the book][book] for more\ndetails.\n\n**Note: This trait must not fail**. The `From` trait is intended for perfect conversions.\nIf the conversion can fail or is not perfect, use [`TryFrom`].\n\n# Generic Implementations\n\n- `From<T> for U` implies [`Into`]`<U> for T`\n- `From` is reflexive, which means that `From<T> for T` is implemented\n\n# Examples\n\n[`String`] implements `From<&str>`:\n\nAn explicit conversion from a `&str` to a String is done as follows:\n\n```rust\nlet string = \"hello\".to_string();\nlet other_string = String::from(\"hello\");\n\nassert_eq!(string, other_string);\n```\n\nWhile performing error handling it is often useful to implement `From` for your own error type.\nBy converting underlying error types to our own custom error type that encapsulates the\nunderlying error type, we can return a single error type without losing information on the\nunderlying cause. The '?' operator automatically converts the underlying error type to our\ncustom error type by calling `Into<CliError>::into` which is automatically provided when\nimplementing `From`. The compiler then infers which implementation of `Into` should be used.\n\n```rust\nuse std::fs;\nuse std::io;\nuse std::num;\n\nenum CliError {\n    IoError(io::Error),\n    ParseError(num::ParseIntError),\n}\n\nimpl From<io::Error> for CliError {\n    fn from(error: io::Error) -> Self {\n        CliError::IoError(error)\n    }\n}\n\nimpl From<num::ParseIntError> for CliError {\n    fn from(error: num::ParseIntError) -> Self {\n        CliError::ParseError(error)\n    }\n}\n\nfn open_and_parse_file(file_name: &str) -> Result<i32, CliError> {\n    let mut contents = fs::read_to_string(&file_name)?;\n    let num: i32 = contents.trim().parse()?;\n    Ok(num)\n}\n```\n\n[`String`]: ../../std/string/struct.String.html\n[`from`]: From::from\n[book]: ../../book/ch09-00-error-handling.html"          },          filterText = "From",          kind = 8,          label = "From",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "From",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "Types that can be safely moved after being pinned.\n\nRust itself has no notion of immovable types, and considers moves (e.g.,\nthrough assignment or [`mem::replace`]) to always be safe.\n\nThe [`Pin`][Pin] type is used instead to prevent moves through the type\nsystem. Pointers `P<T>` wrapped in the [`Pin<P<T>>`][Pin] wrapper can't be\nmoved out of. See the [`pin` module] documentation for more information on\npinning.\n\nImplementing the `Unpin` trait for `T` lifts the restrictions of pinning off\nthe type, which then allows moving `T` out of [`Pin<P<T>>`][Pin] with\nfunctions such as [`mem::replace`].\n\n`Unpin` has no consequence at all for non-pinned data. In particular,\n[`mem::replace`] happily moves `!Unpin` data (it works for any `&mut T`, not\njust when `T: Unpin`). However, you cannot use [`mem::replace`] on data\nwrapped inside a [`Pin<P<T>>`][Pin] because you cannot get the `&mut T` you\nneed for that, and *that* is what makes this system work.\n\nSo this, for example, can only be done on types implementing `Unpin`:\n\n```rust\nuse std::mem;\nuse std::pin::Pin;\n\nlet mut string = \"this\".to_string();\nlet mut pinned_string = Pin::new(&mut string);\n\n// We need a mutable reference to call `mem::replace`.\n// We can obtain such a reference by (implicitly) invoking `Pin::deref_mut`,\n// but that is only possible because `String` implements `Unpin`.\nmem::replace(&mut *pinned_string, \"other\".to_string());\n```\n\nThis trait is automatically implemented for almost every type.\n\n[`mem::replace`]: crate::mem::replace\n[Pin]: crate::pin::Pin\n[`pin` module]: crate::pin"          },          filterText = "Unpin",          kind = 8,          label = "Unpin",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "Unpin",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "The version of the call operator that takes a mutable receiver.\n\nInstances of `FnMut` can be called repeatedly and may mutate state.\n\n`FnMut` is implemented automatically by closures which take mutable\nreferences to captured variables, as well as all types that implement\n[`Fn`], e.g., (safe) [function pointers] (since `FnMut` is a supertrait of\n[`Fn`]). Additionally, for any type `F` that implements `FnMut`, `&mut F`\nimplements `FnMut`, too.\n\nSince [`FnOnce`] is a supertrait of `FnMut`, any instance of `FnMut` can be\nused where a [`FnOnce`] is expected, and since [`Fn`] is a subtrait of\n`FnMut`, any instance of [`Fn`] can be used where `FnMut` is expected.\n\nUse `FnMut` as a bound when you want to accept a parameter of function-like\ntype and need to call it repeatedly, while allowing it to mutate state.\nIf you don't want the parameter to mutate state, use [`Fn`] as a\nbound; if you don't need to call it repeatedly, use [`FnOnce`].\n\nSee the [chapter on closures in *The Rust Programming Language*][book] for\nsome more information on this topic.\n\nAlso of note is the special syntax for `Fn` traits (e.g.\n`Fn(usize, bool) -> usize`). Those interested in the technical details of\nthis can refer to [the relevant section in the *Rustonomicon*][nomicon].\n\n[book]: ../../book/ch13-01-closures.html\n[function pointers]: fn\n[nomicon]: ../../nomicon/hrtb.html\n\n# Examples\n\n## Calling a mutably capturing closure\n\n```rust\nlet mut x = 5;\n{\n    let mut square_x = || x *= x;\n    square_x();\n}\nassert_eq!(x, 25);\n```\n\n## Using a `FnMut` parameter\n\n```rust\nfn do_twice<F>(mut func: F)\n    where F: FnMut()\n{\n    func();\n    func();\n}\n\nlet mut x: usize = 1;\n{\n    let add_two_to_x = || x += 2;\n    do_twice(add_two_to_x);\n}\n\nassert_eq!(x, 5);\n```"          },          filterText = "FnMut",          kind = 8,          label = "FnMut",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "FnMut",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "Extend a collection with the contents of an iterator.\n\nIterators produce a series of values, and collections can also be thought\nof as a series of values. The `Extend` trait bridges this gap, allowing you\nto extend a collection by including the contents of that iterator. When\nextending a collection with an already existing key, that entry is updated\nor, in the case of collections that permit multiple entries with equal\nkeys, that entry is inserted.\n\n# Examples\n\nBasic usage:\n\n```rust\n// You can extend a String with some chars:\nlet mut message = String::from(\"The first three letters are: \");\n\nmessage.extend(&['a', 'b', 'c']);\n\nassert_eq!(\"abc\", &message[29..32]);\n```\n\nImplementing `Extend`:\n\n```rust\n// A sample collection, that's just a wrapper over Vec<T>\n#[derive(Debug)]\nstruct MyCollection(Vec<i32>);\n\n// Let's give it some methods so we can create one and add things\n// to it.\nimpl MyCollection {\n    fn new() -> MyCollection {\n        MyCollection(Vec::new())\n    }\n\n    fn add(&mut self, elem: i32) {\n        self.0.push(elem);\n    }\n}\n\n// since MyCollection has a list of i32s, we implement Extend for i32\nimpl Extend<i32> for MyCollection {\n\n    // This is a bit simpler with the concrete type signature: we can call\n    // extend on anything which can be turned into an Iterator which gives\n    // us i32s. Because we need i32s to put into MyCollection.\n    fn extend<T: IntoIterator<Item=i32>>(&mut self, iter: T) {\n\n        // The implementation is very straightforward: loop through the\n        // iterator, and add() each element to ourselves.\n        for elem in iter {\n            self.add(elem);\n        }\n    }\n}\n\nlet mut c = MyCollection::new();\n\nc.add(5);\nc.add(6);\nc.add(7);\n\n// let's extend our collection with three more numbers\nc.extend(vec![1, 2, 3]);\n\n// we've added these elements onto the end\nassert_eq!(\"MyCollection([5, 6, 7, 1, 2, 3])\", format!(\"{c:?}\"));\n```"          },          filterText = "Extend",          kind = 8,          label = "Extend",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "Extend",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "Trait for equality comparisons which are [partial equivalence\nrelations](https://en.wikipedia.org/wiki/Partial_equivalence_relation).\n\n`x.eq(y)` can also be written `x == y`, and `x.ne(y)` can be written `x != y`.\nWe use the easier-to-read infix notation in the remainder of this documentation.\n\nThis trait allows for partial equality, for types that do not have a full\nequivalence relation. For example, in floating point numbers `NaN != NaN`,\nso floating point types implement `PartialEq` but not [`trait@Eq`].\n\nImplementations must ensure that `eq` and `ne` are consistent with each other:\n\n- `a != b` if and only if `!(a == b)`\n  (ensured by the default implementation).\n\nIf [`PartialOrd`] or [`Ord`] are also implemented for `Self` and `Rhs`, their methods must also\nbe consistent with `PartialEq` (see the documentation of those traits for the exact\nrequirements). It's easy to accidentally make them disagree by deriving some of the traits and\nmanually implementing others.\n\nThe equality relation `==` must satisfy the following conditions\n(for all `a`, `b`, `c` of type `A`, `B`, `C`):\n\n- **Symmetric**: if `A: PartialEq<B>` and `B: PartialEq<A>`, then **`a == b`\n  implies `b == a`**; and\n\n- **Transitive**: if `A: PartialEq<B>` and `B: PartialEq<C>` and `A:\n  PartialEq<C>`, then **`a == b` and `b == c` implies `a == c`**.\n\nNote that the `B: PartialEq<A>` (symmetric) and `A: PartialEq<C>`\n(transitive) impls are not forced to exist, but these requirements apply\nwhenever they do exist.\n\n## Derivable\n\nThis trait can be used with `#[derive]`. When `derive`d on structs, two\ninstances are equal if all fields are equal, and not equal if any fields\nare not equal. When `derive`d on enums, each variant is equal to itself\nand not equal to the other variants.\n\n## How can I implement `PartialEq`?\n\nAn example implementation for a domain in which two books are considered\nthe same book if their ISBN matches, even if the formats differ:\n\n```rust\nenum BookFormat {\n    Paperback,\n    Hardback,\n    Ebook,\n}\n\nstruct Book {\n    isbn: i32,\n    format: BookFormat,\n}\n\nimpl PartialEq for Book {\n    fn eq(&self, other: &Self) -> bool {\n        self.isbn == other.isbn\n    }\n}\n\nlet b1 = Book { isbn: 3, format: BookFormat::Paperback };\nlet b2 = Book { isbn: 3, format: BookFormat::Ebook };\nlet b3 = Book { isbn: 10, format: BookFormat::Paperback };\n\nassert!(b1 == b2);\nassert!(b1 != b3);\n```\n\n## How can I compare two different types?\n\nThe type you can compare with is controlled by `PartialEq`'s type parameter.\nFor example, let's tweak our previous code a bit:\n\n```rust\n// The derive implements <BookFormat> == <BookFormat> comparisons\n#[derive(PartialEq)]\nenum BookFormat {\n    Paperback,\n    Hardback,\n    Ebook,\n}\n\nstruct Book {\n    isbn: i32,\n    format: BookFormat,\n}\n\n// Implement <Book> == <BookFormat> comparisons\nimpl PartialEq<BookFormat> for Book {\n    fn eq(&self, other: &BookFormat) -> bool {\n        self.format == *other\n    }\n}\n\n// Implement <BookFormat> == <Book> comparisons\nimpl PartialEq<Book> for BookFormat {\n    fn eq(&self, other: &Book) -> bool {\n        *self == other.format\n    }\n}\n\nlet b1 = Book { isbn: 3, format: BookFormat::Paperback };\n\nassert!(b1 == BookFormat::Paperback);\nassert!(BookFormat::Ebook != b1);\n```\n\nBy changing `impl PartialEq for Book` to `impl PartialEq<BookFormat> for Book`,\nwe allow `BookFormat`s to be compared with `Book`s.\n\nA comparison like the one above, which ignores some fields of the struct,\ncan be dangerous. It can easily lead to an unintended violation of the\nrequirements for a partial equivalence relation. For example, if we kept\nthe above implementation of `PartialEq<Book>` for `BookFormat` and added an\nimplementation of `PartialEq<Book>` for `Book` (either via a `#[derive]` or\nvia the manual implementation from the first example) then the result would\nviolate transitivity:\n\n```rust\n#[derive(PartialEq)]\nenum BookFormat {\n    Paperback,\n    Hardback,\n    Ebook,\n}\n\n#[derive(PartialEq)]\nstruct Book {\n    isbn: i32,\n    format: BookFormat,\n}\n\nimpl PartialEq<BookFormat> for Book {\n    fn eq(&self, other: &BookFormat) -> bool {\n        self.format == *other\n    }\n}\n\nimpl PartialEq<Book> for BookFormat {\n    fn eq(&self, other: &Book) -> bool {\n        *self == other.format\n    }\n}\n\nfn main() {\n    let b1 = Book { isbn: 1, format: BookFormat::Paperback };\n    let b2 = Book { isbn: 2, format: BookFormat::Paperback };\n\n    assert!(b1 == BookFormat::Paperback);\n    assert!(BookFormat::Paperback == b2);\n\n    // The following should hold by transitivity but doesn't.\n    assert!(b1 == b2); // <-- PANICS\n}\n```\n\n# Examples\n\n```rust\nlet x: u32 = 0;\nlet y: u32 = 1;\n\nassert_eq!(x == y, false);\nassert_eq!(x.eq(&y), false);\n```\n\n[`eq`]: PartialEq::eq\n[`ne`]: PartialEq::ne"          },          filterText = "PartialEq",          kind = 8,          label = "PartialEq",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "PartialEq",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "RustcEncodable",          kind = 18,          label = "RustcEncodable",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "RustcEncodable",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "Custom code within the destructor.\n\nWhen a value is no longer needed, Rust will run a \"destructor\" on that value.\nThe most common way that a value is no longer needed is when it goes out of\nscope. Destructors may still run in other circumstances, but we're going to\nfocus on scope for the examples here. To learn about some of those other cases,\nplease see [the reference] section on destructors.\n\n[the reference]: https://doc.rust-lang.org/reference/destructors.html\n\nThis destructor consists of two components:\n- A call to `Drop::drop` for that value, if this special `Drop` trait is implemented for its type.\n- The automatically generated \"drop glue\" which recursively calls the destructors\n    of all the fields of this value.\n\nAs Rust automatically calls the destructors of all contained fields,\nyou don't have to implement `Drop` in most cases. But there are some cases where\nit is useful, for example for types which directly manage a resource.\nThat resource may be memory, it may be a file descriptor, it may be a network socket.\nOnce a value of that type is no longer going to be used, it should \"clean up\" its\nresource by freeing the memory or closing the file or socket. This is\nthe job of a destructor, and therefore the job of `Drop::drop`.\n\n## Examples\n\nTo see destructors in action, let's take a look at the following program:\n\n```rust\nstruct HasDrop;\n\nimpl Drop for HasDrop {\n    fn drop(&mut self) {\n        println!(\"Dropping HasDrop!\");\n    }\n}\n\nstruct HasTwoDrops {\n    one: HasDrop,\n    two: HasDrop,\n}\n\nimpl Drop for HasTwoDrops {\n    fn drop(&mut self) {\n        println!(\"Dropping HasTwoDrops!\");\n    }\n}\n\nfn main() {\n    let _x = HasTwoDrops { one: HasDrop, two: HasDrop };\n    println!(\"Running!\");\n}\n```\n\nRust will first call `Drop::drop` for `_x` and then for both `_x.one` and `_x.two`,\nmeaning that running this will print\n\n```text\nRunning!\nDropping HasTwoDrops!\nDropping HasDrop!\nDropping HasDrop!\n```\n\nEven if we remove the implementation of `Drop` for `HasTwoDrop`, the destructors of its fields are still called.\nThis would result in\n\n```test\nRunning!\nDropping HasDrop!\nDropping HasDrop!\n```\n\n## You cannot call `Drop::drop` yourself\n\nBecause `Drop::drop` is used to clean up a value, it may be dangerous to use this value after\nthe method has been called. As `Drop::drop` does not take ownership of its input,\nRust prevents misuse by not allowing you to call `Drop::drop` directly.\n\nIn other words, if you tried to explicitly call `Drop::drop` in the above example, you'd get a compiler error.\n\nIf you'd like to explicitly call the destructor of a value, [`mem::drop`] can be used instead.\n\n[`mem::drop`]: drop\n\n## Drop order\n\nWhich of our two `HasDrop` drops first, though? For structs, it's the same\norder that they're declared: first `one`, then `two`. If you'd like to try\nthis yourself, you can modify `HasDrop` above to contain some data, like an\ninteger, and then use it in the `println!` inside of `Drop`. This behavior is\nguaranteed by the language.\n\nUnlike for structs, local variables are dropped in reverse order:\n\n```rust\nstruct Foo;\n\nimpl Drop for Foo {\n    fn drop(&mut self) {\n        println!(\"Dropping Foo!\")\n    }\n}\n\nstruct Bar;\n\nimpl Drop for Bar {\n    fn drop(&mut self) {\n        println!(\"Dropping Bar!\")\n    }\n}\n\nfn main() {\n    let _foo = Foo;\n    let _bar = Bar;\n}\n```\n\nThis will print\n\n```text\nDropping Bar!\nDropping Foo!\n```\n\nPlease see [the reference] for the full rules.\n\n[the reference]: https://doc.rust-lang.org/reference/destructors.html\n\n## `Copy` and `Drop` are exclusive\n\nYou cannot implement both [`Copy`] and `Drop` on the same type. Types that\nare `Copy` get implicitly duplicated by the compiler, making it very\nhard to predict when, and how often destructors will be executed. As such,\nthese types cannot have destructors."          },          filterText = "Drop",          kind = 8,          label = "Drop",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "Drop",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "None",          documentation = {            kind = "markdown",            value = "No value."          },          filterText = "None",          insertTextFormat = 2,          kind = 20,          label = "None",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "None$0",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "A trait for converting a value to a `String`.\n\nThis trait is automatically implemented for any type which implements the\n[`Display`] trait. As such, `ToString` shouldn't be implemented directly:\n[`Display`] should be implemented instead, and you get the `ToString`\nimplementation for free.\n\n[`Display`]: fmt::Display"          },          filterText = "ToString",          kind = 8,          label = "ToString",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "ToString",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          command = {            command = "editor.action.triggerParameterHints",            title = "triggerParameterHints"          },          deprecated = false,          detail = "fn(T)",          documentation = {            kind = "markdown",            value = "Disposes of a value.\n\nThis does so by calling the argument's implementation of [`Drop`][drop].\n\nThis effectively does nothing for types which implement `Copy`, e.g.\nintegers. Such values are copied and _then_ moved into the function, so the\nvalue persists after this function call.\n\nThis function is not magic; it is literally defined as\n\n```rust\npub fn drop<T>(_x: T) { }\n```\n\nBecause `_x` is moved into the function, it is automatically dropped before\nthe function returns.\n\n[drop]: Drop\n\n# Examples\n\nBasic usage:\n\n```rust\nlet v = vec![1, 2, 3];\n\ndrop(v); // explicitly drop the vector\n```\n\nSince [`RefCell`] enforces the borrow rules at runtime, `drop` can\nrelease a [`RefCell`] borrow:\n\n```rust\nuse std::cell::RefCell;\n\nlet x = RefCell::new(1);\n\nlet mut mutable_borrow = x.borrow_mut();\n*mutable_borrow = 1;\n\ndrop(mutable_borrow); // relinquish the mutable borrow on this slot\n\nlet borrow = x.borrow();\nprintln!(\"{}\", *borrow);\n```\n\nIntegers and other types implementing [`Copy`] are unaffected by `drop`.\n\n```rust\n#[derive(Copy, Clone)]\nstruct Foo(u8);\n\nlet x = 1;\nlet y = Foo(2);\ndrop(x); // a copy of `x` is moved and dropped\ndrop(y); // a copy of `y` is moved and dropped\n\nprintln!(\"x: {}, y: {}\", x, y.0); // still available\n```\n\n[`RefCell`]: crate::cell::RefCell"          },          filterText = "drop",          insertTextFormat = 2,          kind = 3,          label = "drop(…)",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "drop(${1:x})$0",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "Trait for types that form a [partial order](https://en.wikipedia.org/wiki/Partial_order).\n\nThe `lt`, `le`, `gt`, and `ge` methods of this trait can be called using\nthe `<`, `<=`, `>`, and `>=` operators, respectively.\n\nThe methods of this trait must be consistent with each other and with those of [`PartialEq`].\nThe following conditions must hold:\n\n1. `a == b` if and only if `partial_cmp(a, b) == Some(Equal)`.\n2. `a < b` if and only if `partial_cmp(a, b) == Some(Less)`\n3. `a > b` if and only if `partial_cmp(a, b) == Some(Greater)`\n4. `a <= b` if and only if `a < b || a == b`\n5. `a >= b` if and only if `a > b || a == b`\n6. `a != b` if and only if `!(a == b)`.\n\nConditions 2–5 above are ensured by the default implementation.\nCondition 6 is already ensured by [`PartialEq`].\n\nIf [`Ord`] is also implemented for `Self` and `Rhs`, it must also be consistent with\n`partial_cmp` (see the documentation of that trait for the exact requirements). It's\neasy to accidentally make them disagree by deriving some of the traits and manually\nimplementing others.\n\nThe comparison must satisfy, for all `a`, `b` and `c`:\n\n- transitivity: `a < b` and `b < c` implies `a < c`. The same must hold for both `==` and `>`.\n- duality: `a < b` if and only if `b > a`.\n\nNote that these requirements mean that the trait itself must be implemented symmetrically and\ntransitively: if `T: PartialOrd<U>` and `U: PartialOrd<V>` then `U: PartialOrd<T>` and `T:\nPartialOrd<V>`.\n\n## Corollaries\n\nThe following corollaries follow from the above requirements:\n\n- irreflexivity of `<` and `>`: `!(a < a)`, `!(a > a)`\n- transitivity of `>`: if `a > b` and `b > c` then `a > c`\n- duality of `partial_cmp`: `partial_cmp(a, b) == partial_cmp(b, a).map(Ordering::reverse)`\n\n## Derivable\n\nThis trait can be used with `#[derive]`.\n\nWhen `derive`d on structs, it will produce a\n[lexicographic](https://en.wikipedia.org/wiki/Lexicographic_order) ordering\nbased on the top-to-bottom declaration order of the struct's members.\n\nWhen `derive`d on enums, variants are ordered by their discriminants.\nBy default, the discriminant is smallest for variants at the top, and\nlargest for variants at the bottom. Here's an example:\n\n```rust\n#[derive(PartialEq, PartialOrd)]\nenum E {\n    Top,\n    Bottom,\n}\n\nassert!(E::Top < E::Bottom);\n```\n\nHowever, manually setting the discriminants can override this default\nbehavior:\n\n```rust\n#[derive(PartialEq, PartialOrd)]\nenum E {\n    Top = 2,\n    Bottom = 1,\n}\n\nassert!(E::Bottom < E::Top);\n```\n\n## How can I implement `PartialOrd`?\n\n`PartialOrd` only requires implementation of the [`partial_cmp`] method, with the others\ngenerated from default implementations.\n\nHowever it remains possible to implement the others separately for types which do not have a\ntotal order. For example, for floating point numbers, `NaN < 0 == false` and `NaN >= 0 ==\nfalse` (cf. IEEE 754-2008 section 5.11).\n\n`PartialOrd` requires your type to be [`PartialEq`].\n\nIf your type is [`Ord`], you can implement [`partial_cmp`] by using [`cmp`]:\n\n```rust\nuse std::cmp::Ordering;\n\n#[derive(Eq)]\nstruct Person {\n    id: u32,\n    name: String,\n    height: u32,\n}\n\nimpl PartialOrd for Person {\n    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {\n        Some(self.cmp(other))\n    }\n}\n\nimpl Ord for Person {\n    fn cmp(&self, other: &Self) -> Ordering {\n        self.height.cmp(&other.height)\n    }\n}\n\nimpl PartialEq for Person {\n    fn eq(&self, other: &Self) -> bool {\n        self.height == other.height\n    }\n}\n```\n\nYou may also find it useful to use [`partial_cmp`] on your type's fields. Here\nis an example of `Person` types who have a floating-point `height` field that\nis the only field to be used for sorting:\n\n```rust\nuse std::cmp::Ordering;\n\nstruct Person {\n    id: u32,\n    name: String,\n    height: f64,\n}\n\nimpl PartialOrd for Person {\n    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {\n        self.height.partial_cmp(&other.height)\n    }\n}\n\nimpl PartialEq for Person {\n    fn eq(&self, other: &Self) -> bool {\n        self.height == other.height\n    }\n}\n```\n\n# Examples\n\n```rust\nlet x: u32 = 0;\nlet y: u32 = 1;\n\nassert_eq!(x < y, true);\nassert_eq!(x.lt(&y), true);\n```\n\n[`partial_cmp`]: PartialOrd::partial_cmp\n[`cmp`]: Ord::cmp"          },          filterText = "PartialOrd",          kind = 8,          label = "PartialOrd",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "PartialOrd",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "The `Option` type. See [the module level documentation](self) for more."          },          filterText = "Option",          kind = 13,          label = "Option",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "Option",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "Types whose values can be duplicated simply by copying bits.\n\nBy default, variable bindings have 'move semantics.' In other\nwords:\n\n```rust\n#[derive(Debug)]\nstruct Foo;\n\nlet x = Foo;\n\nlet y = x;\n\n// `x` has moved into `y`, and so cannot be used\n\n// println!(\"{x:?}\"); // error: use of moved value\n```\n\nHowever, if a type implements `Copy`, it instead has 'copy semantics':\n\n```rust\n// We can derive a `Copy` implementation. `Clone` is also required, as it's\n// a supertrait of `Copy`.\n#[derive(Debug, Copy, Clone)]\nstruct Foo;\n\nlet x = Foo;\n\nlet y = x;\n\n// `y` is a copy of `x`\n\nprintln!(\"{x:?}\"); // A-OK!\n```\n\nIt's important to note that in these two examples, the only difference is whether you\nare allowed to access `x` after the assignment. Under the hood, both a copy and a move\ncan result in bits being copied in memory, although this is sometimes optimized away.\n\n## How can I implement `Copy`?\n\nThere are two ways to implement `Copy` on your type. The simplest is to use `derive`:\n\n```rust\n#[derive(Copy, Clone)]\nstruct MyStruct;\n```\n\nYou can also implement `Copy` and `Clone` manually:\n\n```rust\nstruct MyStruct;\n\nimpl Copy for MyStruct { }\n\nimpl Clone for MyStruct {\n    fn clone(&self) -> MyStruct {\n        *self\n    }\n}\n```\n\nThere is a small difference between the two: the `derive` strategy will also place a `Copy`\nbound on type parameters, which isn't always desired.\n\n## What's the difference between `Copy` and `Clone`?\n\nCopies happen implicitly, for example as part of an assignment `y = x`. The behavior of\n`Copy` is not overloadable; it is always a simple bit-wise copy.\n\nCloning is an explicit action, `x.clone()`. The implementation of [`Clone`] can\nprovide any type-specific behavior necessary to duplicate values safely. For example,\nthe implementation of [`Clone`] for [`String`] needs to copy the pointed-to string\nbuffer in the heap. A simple bitwise copy of [`String`] values would merely copy the\npointer, leading to a double free down the line. For this reason, [`String`] is [`Clone`]\nbut not `Copy`.\n\n[`Clone`] is a supertrait of `Copy`, so everything which is `Copy` must also implement\n[`Clone`]. If a type is `Copy` then its [`Clone`] implementation only needs to return `*self`\n(see the example above).\n\n## When can my type be `Copy`?\n\nA type can implement `Copy` if all of its components implement `Copy`. For example, this\nstruct can be `Copy`:\n\n```rust\n#[derive(Copy, Clone)]\nstruct Point {\n   x: i32,\n   y: i32,\n}\n```\n\nA struct can be `Copy`, and [`i32`] is `Copy`, therefore `Point` is eligible to be `Copy`.\nBy contrast, consider\n\n```rust\nstruct PointList {\n    points: Vec<Point>,\n}\n```\n\nThe struct `PointList` cannot implement `Copy`, because [`Vec<T>`] is not `Copy`. If we\nattempt to derive a `Copy` implementation, we'll get an error:\n\n```text\nthe trait `Copy` may not be implemented for this type; field `points` does not implement `Copy`\n```\n\nShared references (`&T`) are also `Copy`, so a type can be `Copy`, even when it holds\nshared references of types `T` that are *not* `Copy`. Consider the following struct,\nwhich can implement `Copy`, because it only holds a *shared reference* to our non-`Copy`\ntype `PointList` from above:\n\n```rust\n#[derive(Copy, Clone)]\nstruct PointListWrapper<'a> {\n    point_list_ref: &'a PointList,\n}\n```\n\n## When *can't* my type be `Copy`?\n\nSome types can't be copied safely. For example, copying `&mut T` would create an aliased\nmutable reference. Copying [`String`] would duplicate responsibility for managing the\n[`String`]'s buffer, leading to a double free.\n\nGeneralizing the latter case, any type implementing [`Drop`] can't be `Copy`, because it's\nmanaging some resource besides its own [`size_of::<T>`] bytes.\n\nIf you try to implement `Copy` on a struct or enum containing non-`Copy` data, you will get\nthe error [E0204].\n\n[E0204]: ../../error-index.html#E0204\n\n## When *should* my type be `Copy`?\n\nGenerally speaking, if your type _can_ implement `Copy`, it should. Keep in mind, though,\nthat implementing `Copy` is part of the public API of your type. If the type might become\nnon-`Copy` in the future, it could be prudent to omit the `Copy` implementation now, to\navoid a breaking API change.\n\n## Additional implementors\n\nIn addition to the [implementors listed below][impls],\nthe following types also implement `Copy`:\n\n* Function item types (i.e., the distinct types defined for each function)\n* Function pointer types (e.g., `fn() -> i32`)\n* Tuple types, if each component also implements `Copy` (e.g., `()`, `(i32, bool)`)\n* Closure types, if they capture no value from the environment\n  or if all such captured values implement `Copy` themselves.\n  Note that variables captured by shared reference always implement `Copy`\n  (even if the referent doesn't),\n  while variables captured by mutable reference never implement `Copy`.\n\n[`Vec<T>`]: ../../std/vec/struct.Vec.html\n[`String`]: ../../std/string/struct.String.html\n[`size_of::<T>`]: crate::mem::size_of\n[impls]: #implementors"          },          filterText = "Copy",          kind = 8,          label = "Copy",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "Copy",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "Simple and safe type conversions that may fail in a controlled\nway under some circumstances. It is the reciprocal of [`TryInto`].\n\nThis is useful when you are doing a type conversion that may\ntrivially succeed but may also need special handling.\nFor example, there is no way to convert an [`i64`] into an [`i32`]\nusing the [`From`] trait, because an [`i64`] may contain a value\nthat an [`i32`] cannot represent and so the conversion would lose data.\nThis might be handled by truncating the [`i64`] to an [`i32`] (essentially\ngiving the [`i64`]'s value modulo [`i32::MAX`]) or by simply returning\n[`i32::MAX`], or by some other method.  The [`From`] trait is intended\nfor perfect conversions, so the `TryFrom` trait informs the\nprogrammer when a type conversion could go bad and lets them\ndecide how to handle it.\n\n# Generic Implementations\n\n- `TryFrom<T> for U` implies [`TryInto`]`<U> for T`\n- [`try_from`] is reflexive, which means that `TryFrom<T> for T`\nis implemented and cannot fail -- the associated `Error` type for\ncalling `T::try_from()` on a value of type `T` is [`Infallible`].\nWhen the [`!`] type is stabilized [`Infallible`] and [`!`] will be\nequivalent.\n\n`TryFrom<T>` can be implemented as follows:\n\n```rust\nstruct GreaterThanZero(i32);\n\nimpl TryFrom<i32> for GreaterThanZero {\n    type Error = &'static str;\n\n    fn try_from(value: i32) -> Result<Self, Self::Error> {\n        if value <= 0 {\n            Err(\"GreaterThanZero only accepts value superior than zero!\")\n        } else {\n            Ok(GreaterThanZero(value))\n        }\n    }\n}\n```\n\n# Examples\n\nAs described, [`i32`] implements `TryFrom<`[`i64`]`>`:\n\n```rust\nlet big_number = 1_000_000_000_000i64;\n// Silently truncates `big_number`, requires detecting\n// and handling the truncation after the fact.\nlet smaller_number = big_number as i32;\nassert_eq!(smaller_number, -727379968);\n\n// Returns an error because `big_number` is too big to\n// fit in an `i32`.\nlet try_smaller_number = i32::try_from(big_number);\nassert!(try_smaller_number.is_err());\n\n// Returns `Ok(3)`.\nlet try_successful_smaller_number = i32::try_from(3);\nassert!(try_successful_smaller_number.is_ok());\n```\n\n[`try_from`]: TryFrom::try_from"          },          filterText = "TryFrom",          kind = 8,          label = "TryFrom",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "TryFrom",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "A UTF-8–encoded, growable string.\n\nThe `String` type is the most common string type that has ownership over the\ncontents of the string. It has a close relationship with its borrowed\ncounterpart, the primitive [`str`].\n\n# Examples\n\nYou can create a `String` from [a literal string][`&str`] with [`String::from`]:\n\n[`String::from`]: From::from\n\n```rust\nlet hello = String::from(\"Hello, world!\");\n```\n\nYou can append a [`char`] to a `String` with the [`push`] method, and\nappend a [`&str`] with the [`push_str`] method:\n\n```rust\nlet mut hello = String::from(\"Hello, \");\n\nhello.push('w');\nhello.push_str(\"orld!\");\n```\n\n[`push`]: String::push\n[`push_str`]: String::push_str\n\nIf you have a vector of UTF-8 bytes, you can create a `String` from it with\nthe [`from_utf8`] method:\n\n```rust\n// some bytes, in a vector\nlet sparkle_heart = vec![240, 159, 146, 150];\n\n// We know these bytes are valid, so we'll use `unwrap()`.\nlet sparkle_heart = String::from_utf8(sparkle_heart).unwrap();\n\nassert_eq!(\"💖\", sparkle_heart);\n```\n\n[`from_utf8`]: String::from_utf8\n\n# UTF-8\n\n`String`s are always valid UTF-8. This has a few implications, the first of\nwhich is that if you need a non-UTF-8 string, consider [`OsString`]. It is\nsimilar, but without the UTF-8 constraint. The second implication is that\nyou cannot index into a `String`:\n\n```rust\nlet s = \"hello\";\n\nprintln!(\"The first letter of s is {}\", s[0]); // ERROR!!!\n```\n\n[`OsString`]: ../../std/ffi/struct.OsString.html \"ffi::OsString\"\n\nIndexing is intended to be a constant-time operation, but UTF-8 encoding\ndoes not allow us to do this. Furthermore, it's not clear what sort of\nthing the index should return: a byte, a codepoint, or a grapheme cluster.\nThe [`bytes`] and [`chars`] methods return iterators over the first\ntwo, respectively.\n\n[`bytes`]: str::bytes\n[`chars`]: str::chars\n\n# Deref\n\n`String` implements <code>[Deref]<Target = [str]></code>, and so inherits all of [`str`]'s\nmethods. In addition, this means that you can pass a `String` to a\nfunction which takes a [`&str`] by using an ampersand (`&`):\n\n```rust\nfn takes_str(s: &str) { }\n\nlet s = String::from(\"Hello\");\n\ntakes_str(&s);\n```\n\nThis will create a [`&str`] from the `String` and pass it in. This\nconversion is very inexpensive, and so generally, functions will accept\n[`&str`]s as arguments unless they need a `String` for some specific\nreason.\n\nIn certain cases Rust doesn't have enough information to make this\nconversion, known as [`Deref`] coercion. In the following example a string\nslice [`&'a str`][`&str`] implements the trait `TraitExample`, and the function\n`example_func` takes anything that implements the trait. In this case Rust\nwould need to make two implicit conversions, which Rust doesn't have the\nmeans to do. For that reason, the following example will not compile.\n\n```rust\ntrait TraitExample {}\n\nimpl<'a> TraitExample for &'a str {}\n\nfn example_func<A: TraitExample>(example_arg: A) {}\n\nlet example_string = String::from(\"example_string\");\nexample_func(&example_string);\n```\n\nThere are two options that would work instead. The first would be to\nchange the line `example_func(&example_string);` to\n`example_func(example_string.as_str());`, using the method [`as_str()`]\nto explicitly extract the string slice containing the string. The second\nway changes `example_func(&example_string);` to\n`example_func(&*example_string);`. In this case we are dereferencing a\n`String` to a [`str`], then referencing the [`str`] back to\n[`&str`]. The second way is more idiomatic, however both work to do the\nconversion explicitly rather than relying on the implicit conversion.\n\n# Representation\n\nA `String` is made up of three components: a pointer to some bytes, a\nlength, and a capacity. The pointer points to an internal buffer `String`\nuses to store its data. The length is the number of bytes currently stored\nin the buffer, and the capacity is the size of the buffer in bytes. As such,\nthe length will always be less than or equal to the capacity.\n\nThis buffer is always stored on the heap.\n\nYou can look at these with the [`as_ptr`], [`len`], and [`capacity`]\nmethods:\n\n```rust\nuse std::mem;\n\nlet story = String::from(\"Once upon a time...\");\n\n// Prevent automatically dropping the String's data\nlet mut story = mem::ManuallyDrop::new(story);\n\nlet ptr = story.as_mut_ptr();\nlet len = story.len();\nlet capacity = story.capacity();\n\n// story has nineteen bytes\nassert_eq!(19, len);\n\n// We can re-build a String out of ptr, len, and capacity. This is all\n// unsafe because we are responsible for making sure the components are\n// valid:\nlet s = unsafe { String::from_raw_parts(ptr, len, capacity) } ;\n\nassert_eq!(String::from(\"Once upon a time...\"), s);\n```\n\n[`as_ptr`]: str::as_ptr\n[`len`]: String::len\n[`capacity`]: String::capacity\n\nIf a `String` has enough capacity, adding elements to it will not\nre-allocate. For example, consider this program:\n\n```rust\nlet mut s = String::new();\n\nprintln!(\"{}\", s.capacity());\n\nfor _ in 0..5 {\n    s.push_str(\"hello\");\n    println!(\"{}\", s.capacity());\n}\n```\n\nThis will output the following:\n\n```text\n0\n5\n10\n20\n20\n40\n```\n\nAt first, we have no memory allocated at all, but as we append to the\nstring, it increases its capacity appropriately. If we instead use the\n[`with_capacity`] method to allocate the correct capacity initially:\n\n```rust\nlet mut s = String::with_capacity(25);\n\nprintln!(\"{}\", s.capacity());\n\nfor _ in 0..5 {\n    s.push_str(\"hello\");\n    println!(\"{}\", s.capacity());\n}\n```\n\n[`with_capacity`]: String::with_capacity\n\nWe end up with a different output:\n\n```text\n25\n25\n25\n25\n25\n25\n```\n\nHere, there's no need to allocate more memory inside the loop.\n\n[str]: prim@str \"str\"\n[`str`]: prim@str \"str\"\n[`&str`]: prim@str \"&str\"\n[Deref]: core::ops::Deref \"ops::Deref\"\n[`Deref`]: core::ops::Deref \"ops::Deref\"\n[`as_str()`]: String::as_str"          },          filterText = "String",          kind = 22,          label = "String",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "String",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "Trait for equality comparisons which are [equivalence relations](\nhttps://en.wikipedia.org/wiki/Equivalence_relation).\n\nThis means, that in addition to `a == b` and `a != b` being strict inverses, the equality must\nbe (for all `a`, `b` and `c`):\n\n- reflexive: `a == a`;\n- symmetric: `a == b` implies `b == a`; and\n- transitive: `a == b` and `b == c` implies `a == c`.\n\nThis property cannot be checked by the compiler, and therefore `Eq` implies\n[`PartialEq`], and has no extra methods.\n\n## Derivable\n\nThis trait can be used with `#[derive]`. When `derive`d, because `Eq` has\nno extra methods, it is only informing the compiler that this is an\nequivalence relation rather than a partial equivalence relation. Note that\nthe `derive` strategy requires all fields are `Eq`, which isn't\nalways desired.\n\n## How can I implement `Eq`?\n\nIf you cannot use the `derive` strategy, specify that your type implements\n`Eq`, which has no methods:\n\n```rust\nenum BookFormat { Paperback, Hardback, Ebook }\nstruct Book {\n    isbn: i32,\n    format: BookFormat,\n}\nimpl PartialEq for Book {\n    fn eq(&self, other: &Self) -> bool {\n        self.isbn == other.isbn\n    }\n}\nimpl Eq for Book {}\n```"          },          filterText = "Eq",          kind = 8,          label = "Eq",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "Eq",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "A value-to-value conversion that consumes the input value. The\nopposite of [`From`].\n\nOne should avoid implementing [`Into`] and implement [`From`] instead.\nImplementing [`From`] automatically provides one with an implementation of [`Into`]\nthanks to the blanket implementation in the standard library.\n\nPrefer using [`Into`] over [`From`] when specifying trait bounds on a generic function\nto ensure that types that only implement [`Into`] can be used as well.\n\n**Note: This trait must not fail**. If the conversion can fail, use [`TryInto`].\n\n# Generic Implementations\n\n- [`From`]`<T> for U` implies `Into<U> for T`\n- [`Into`] is reflexive, which means that `Into<T> for T` is implemented\n\n# Implementing [`Into`] for conversions to external types in old versions of Rust\n\nPrior to Rust 1.41, if the destination type was not part of the current crate\nthen you couldn't implement [`From`] directly.\nFor example, take this code:\n\n```rust\nstruct Wrapper<T>(Vec<T>);\nimpl<T> From<Wrapper<T>> for Vec<T> {\n    fn from(w: Wrapper<T>) -> Vec<T> {\n        w.0\n    }\n}\n```\nThis will fail to compile in older versions of the language because Rust's orphaning rules\nused to be a little bit more strict. To bypass this, you could implement [`Into`] directly:\n\n```rust\nstruct Wrapper<T>(Vec<T>);\nimpl<T> Into<Vec<T>> for Wrapper<T> {\n    fn into(self) -> Vec<T> {\n        self.0\n    }\n}\n```\n\nIt is important to understand that [`Into`] does not provide a [`From`] implementation\n(as [`From`] does with [`Into`]). Therefore, you should always try to implement [`From`]\nand then fall back to [`Into`] if [`From`] can't be implemented.\n\n# Examples\n\n[`String`] implements [`Into`]`<`[`Vec`]`<`[`u8`]`>>`:\n\nIn order to express that we want a generic function to take all arguments that can be\nconverted to a specified type `T`, we can use a trait bound of [`Into`]`<T>`.\nFor example: The function `is_hello` takes all arguments that can be converted into a\n[`Vec`]`<`[`u8`]`>`.\n\n```rust\nfn is_hello<T: Into<Vec<u8>>>(s: T) {\n   let bytes = b\"hello\".to_vec();\n   assert_eq!(bytes, s.into());\n}\n\nlet s = \"hello\".to_string();\nis_hello(s);\n```\n\n[`String`]: ../../std/string/struct.String.html\n[`Vec`]: ../../std/vec/struct.Vec.html"          },          filterText = "Into",          kind = 8,          label = "Into",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "Into",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "A common trait for the ability to explicitly duplicate an object.\n\nDiffers from [`Copy`] in that [`Copy`] is implicit and an inexpensive bit-wise copy, while\n`Clone` is always explicit and may or may not be expensive. In order to enforce\nthese characteristics, Rust does not allow you to reimplement [`Copy`], but you\nmay reimplement `Clone` and run arbitrary code.\n\nSince `Clone` is more general than [`Copy`], you can automatically make anything\n[`Copy`] be `Clone` as well.\n\n## Derivable\n\nThis trait can be used with `#[derive]` if all fields are `Clone`. The `derive`d\nimplementation of [`Clone`] calls [`clone`] on each field.\n\n[`clone`]: Clone::clone\n\nFor a generic struct, `#[derive]` implements `Clone` conditionally by adding bound `Clone` on\ngeneric parameters.\n\n```rust\n// `derive` implements Clone for Reading<T> when T is Clone.\n#[derive(Clone)]\nstruct Reading<T> {\n    frequency: T,\n}\n```\n\n## How can I implement `Clone`?\n\nTypes that are [`Copy`] should have a trivial implementation of `Clone`. More formally:\nif `T: Copy`, `x: T`, and `y: &T`, then `let x = y.clone();` is equivalent to `let x = *y;`.\nManual implementations should be careful to uphold this invariant; however, unsafe code\nmust not rely on it to ensure memory safety.\n\nAn example is a generic struct holding a function pointer. In this case, the\nimplementation of `Clone` cannot be `derive`d, but can be implemented as:\n\n```rust\nstruct Generate<T>(fn() -> T);\n\nimpl<T> Copy for Generate<T> {}\n\nimpl<T> Clone for Generate<T> {\n    fn clone(&self) -> Self {\n        *self\n    }\n}\n```\n\n## Additional implementors\n\nIn addition to the [implementors listed below][impls],\nthe following types also implement `Clone`:\n\n* Function item types (i.e., the distinct types defined for each function)\n* Function pointer types (e.g., `fn() -> i32`)\n* Tuple types, if each component also implements `Clone` (e.g., `()`, `(i32, bool)`)\n* Closure types, if they capture no value from the environment\n  or if all such captured values implement `Clone` themselves.\n  Note that variables captured by shared reference always implement `Clone`\n  (even if the referent doesn't),\n  while variables captured by mutable reference never implement `Clone`.\n\n[impls]: #implementors"          },          filterText = "Clone",          kind = 8,          label = "Clone",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "Clone",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "`Result` is a type that represents either success ([`Ok`]) or failure ([`Err`]).\n\nSee the [module documentation](self) for details."          },          filterText = "Result",          kind = 13,          label = "Result",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "Result",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "An attempted conversion that consumes `self`, which may or may not be\nexpensive.\n\nLibrary authors should usually not directly implement this trait,\nbut should prefer implementing the [`TryFrom`] trait, which offers\ngreater flexibility and provides an equivalent `TryInto`\nimplementation for free, thanks to a blanket implementation in the\nstandard library. For more information on this, see the\ndocumentation for [`Into`].\n\n# Implementing `TryInto`\n\nThis suffers the same restrictions and reasoning as implementing\n[`Into`], see there for details."          },          filterText = "TryInto",          kind = 8,          label = "TryInto",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "TryInto",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "A pointer type for heap allocation.\n\nSee the [module-level documentation](../../std/boxed/index.html) for more."          },          filterText = "Box",          kind = 22,          label = "Box",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "Box",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "Conversion from an [`Iterator`].\n\nBy implementing `FromIterator` for a type, you define how it will be\ncreated from an iterator. This is common for types which describe a\ncollection of some kind.\n\nIf you want to create a collection from the contents of an iterator, the\n[`Iterator::collect()`] method is preferred. However, when you need to\nspecify the container type, [`FromIterator::from_iter()`] can be more\nreadable than using a turbofish (e.g. `::<Vec<_>>()`). See the\n[`Iterator::collect()`] documentation for more examples of its use.\n\nSee also: [`IntoIterator`].\n\n# Examples\n\nBasic usage:\n\n```rust\nlet five_fives = std::iter::repeat(5).take(5);\n\nlet v = Vec::from_iter(five_fives);\n\nassert_eq!(v, vec![5, 5, 5, 5, 5]);\n```\n\nUsing [`Iterator::collect()`] to implicitly use `FromIterator`:\n\n```rust\nlet five_fives = std::iter::repeat(5).take(5);\n\nlet v: Vec<i32> = five_fives.collect();\n\nassert_eq!(v, vec![5, 5, 5, 5, 5]);\n```\n\nUsing [`FromIterator::from_iter()`] as a more readable alternative to\n[`Iterator::collect()`]:\n\n```rust\nuse std::collections::VecDeque;\nlet first = (0..10).collect::<VecDeque<i32>>();\nlet second = VecDeque::from_iter(0..10);\n\nassert_eq!(first, second);\n```\n\nImplementing `FromIterator` for your type:\n\n```rust\n// A sample collection, that's just a wrapper over Vec<T>\n#[derive(Debug)]\nstruct MyCollection(Vec<i32>);\n\n// Let's give it some methods so we can create one and add things\n// to it.\nimpl MyCollection {\n    fn new() -> MyCollection {\n        MyCollection(Vec::new())\n    }\n\n    fn add(&mut self, elem: i32) {\n        self.0.push(elem);\n    }\n}\n\n// and we'll implement FromIterator\nimpl FromIterator<i32> for MyCollection {\n    fn from_iter<I: IntoIterator<Item=i32>>(iter: I) -> Self {\n        let mut c = MyCollection::new();\n\n        for i in iter {\n            c.add(i);\n        }\n\n        c\n    }\n}\n\n// Now we can make a new iterator...\nlet iter = (0..5).into_iter();\n\n// ... and make a MyCollection out of it\nlet c = MyCollection::from_iter(iter);\n\nassert_eq!(c.0, vec![0, 1, 2, 3, 4]);\n\n// collect works too!\n\nlet iter = (0..5).into_iter();\nlet c: MyCollection = iter.collect();\n\nassert_eq!(c.0, vec![0, 1, 2, 3, 4]);\n```"          },          filterText = "FromIterator",          kind = 8,          label = "FromIterator",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "FromIterator",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "An iterator that knows its exact length.\n\nMany [`Iterator`]s don't know how many times they will iterate, but some do.\nIf an iterator knows how many times it can iterate, providing access to\nthat information can be useful. For example, if you want to iterate\nbackwards, a good start is to know where the end is.\n\nWhen implementing an `ExactSizeIterator`, you must also implement\n[`Iterator`]. When doing so, the implementation of [`Iterator::size_hint`]\n*must* return the exact size of the iterator.\n\nThe [`len`] method has a default implementation, so you usually shouldn't\nimplement it. However, you may be able to provide a more performant\nimplementation than the default, so overriding it in this case makes sense.\n\nNote that this trait is a safe trait and as such does *not* and *cannot*\nguarantee that the returned length is correct. This means that `unsafe`\ncode **must not** rely on the correctness of [`Iterator::size_hint`]. The\nunstable and unsafe [`TrustedLen`](super::marker::TrustedLen) trait gives\nthis additional guarantee.\n\n[`len`]: ExactSizeIterator::len\n\n# Examples\n\nBasic usage:\n\n```rust\n// a finite range knows exactly how many times it will iterate\nlet five = 0..5;\n\nassert_eq!(5, five.len());\n```\n\nIn the [module-level docs], we implemented an [`Iterator`], `Counter`.\nLet's implement `ExactSizeIterator` for it as well:\n\n[module-level docs]: crate::iter\n\n```rust\nimpl ExactSizeIterator for Counter {\n    // We can easily calculate the remaining number of iterations.\n    fn len(&self) -> usize {\n        5 - self.count\n    }\n}\n\n// And now we can use it!\n\nlet counter = Counter::new();\n\nassert_eq!(5, counter.len());\n```"          },          filterText = "ExactSizeIterator",          kind = 8,          label = "ExactSizeIterator",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "ExactSizeIterator",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "Ok(T)",          documentation = {            kind = "markdown",            value = "Contains the success value"          },          filterText = "Ok(…)",          insertTextFormat = 2,          kind = 20,          label = "Ok(…)",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "Ok(${1:()})$0",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = 'Used to do a cheap reference-to-reference conversion.\n\nThis trait is similar to [`AsMut`] which is used for converting between mutable references.\nIf you need to do a costly conversion it is better to implement [`From`] with type\n`&T` or write a custom function.\n\n`AsRef` has the same signature as [`Borrow`], but [`Borrow`] is different in few aspects:\n\n- Unlike `AsRef`, [`Borrow`] has a blanket impl for any `T`, and can be used to accept either\n  a reference or a value.\n- [`Borrow`] also requires that [`Hash`], [`Eq`] and [`Ord`] for borrowed value are\n  equivalent to those of the owned value. For this reason, if you want to\n  borrow only a single field of a struct you can implement `AsRef`, but not [`Borrow`].\n\n**Note: This trait must not fail**. If the conversion can fail, use a\ndedicated method which returns an [`Option<T>`] or a [`Result<T, E>`].\n\n# Generic Implementations\n\n- `AsRef` auto-dereferences if the inner type is a reference or a mutable\n  reference (e.g.: `foo.as_ref()` will work the same if `foo` has type\n  `&mut Foo` or `&&mut Foo`)\n\n# Examples\n\nBy using trait bounds we can accept arguments of different types as long as they can be\nconverted to the specified type `T`.\n\nFor example: By creating a generic function that takes an `AsRef<str>` we express that we\nwant to accept all references that can be converted to [`&str`] as an argument.\nSince both [`String`] and [`&str`] implement `AsRef<str>` we can accept both as input argument.\n\n[`&str`]: primitive@str\n[`Borrow`]: crate::borrow::Borrow\n[`Eq`]: crate::cmp::Eq\n[`Ord`]: crate::cmp::Ord\n[`String`]: ../../std/string/struct.String.html\n\n```rust\nfn is_hello<T: AsRef<str>>(s: T) {\n   assert_eq!("hello", s.as_ref());\n}\n\nlet s = "hello";\nis_hello(s);\n\nlet s = "hello".to_string();\nis_hello(s);\n```'          },          filterText = "AsRef",          kind = 8,          label = "AsRef",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "AsRef",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "An interface for dealing with iterators.\n\nThis is the main iterator trait. For more about the concept of iterators\ngenerally, please see the [module-level documentation]. In particular, you\nmay want to know how to [implement `Iterator`][impl].\n\n[module-level documentation]: crate::iter\n[impl]: crate::iter#implementing-iterator"          },          filterText = "Iterator",          kind = 8,          label = "Iterator",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "Iterator",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "Trait for types that form a [total order](https://en.wikipedia.org/wiki/Total_order).\n\nImplementations must be consistent with the [`PartialOrd`] implementation, and ensure\n`max`, `min`, and `clamp` are consistent with `cmp`:\n\n- `partial_cmp(a, b) == Some(cmp(a, b))`.\n- `max(a, b) == max_by(a, b, cmp)` (ensured by the default implementation).\n- `min(a, b) == min_by(a, b, cmp)` (ensured by the default implementation).\n- For `a.clamp(min, max)`, see the [method docs](#method.clamp)\n  (ensured by the default implementation).\n\nIt's easy to accidentally make `cmp` and `partial_cmp` disagree by\nderiving some of the traits and manually implementing others.\n\n## Corollaries\n\nFrom the above and the requirements of `PartialOrd`, it follows that `<` defines a strict total order.\nThis means that for all `a`, `b` and `c`:\n\n- exactly one of `a < b`, `a == b` or `a > b` is true; and\n- `<` is transitive: `a < b` and `b < c` implies `a < c`. The same must hold for both `==` and `>`.\n\n## Derivable\n\nThis trait can be used with `#[derive]`.\n\nWhen `derive`d on structs, it will produce a\n[lexicographic](https://en.wikipedia.org/wiki/Lexicographic_order) ordering\nbased on the top-to-bottom declaration order of the struct's members.\n\nWhen `derive`d on enums, variants are ordered by their discriminants.\nBy default, the discriminant is smallest for variants at the top, and\nlargest for variants at the bottom. Here's an example:\n\n```rust\n#[derive(PartialEq, Eq, PartialOrd, Ord)]\nenum E {\n    Top,\n    Bottom,\n}\n\nassert!(E::Top < E::Bottom);\n```\n\nHowever, manually setting the discriminants can override this default\nbehavior:\n\n```rust\n#[derive(PartialEq, Eq, PartialOrd, Ord)]\nenum E {\n    Top = 2,\n    Bottom = 1,\n}\n\nassert!(E::Bottom < E::Top);\n```\n\n## Lexicographical comparison\n\nLexicographical comparison is an operation with the following properties:\n - Two sequences are compared element by element.\n - The first mismatching element defines which sequence is lexicographically less or greater than the other.\n - If one sequence is a prefix of another, the shorter sequence is lexicographically less than the other.\n - If two sequence have equivalent elements and are of the same length, then the sequences are lexicographically equal.\n - An empty sequence is lexicographically less than any non-empty sequence.\n - Two empty sequences are lexicographically equal.\n\n## How can I implement `Ord`?\n\n`Ord` requires that the type also be [`PartialOrd`] and [`Eq`] (which requires [`PartialEq`]).\n\nThen you must define an implementation for [`cmp`]. You may find it useful to use\n[`cmp`] on your type's fields.\n\nHere's an example where you want to sort people by height only, disregarding `id`\nand `name`:\n\n```rust\nuse std::cmp::Ordering;\n\n#[derive(Eq)]\nstruct Person {\n    id: u32,\n    name: String,\n    height: u32,\n}\n\nimpl Ord for Person {\n    fn cmp(&self, other: &Self) -> Ordering {\n        self.height.cmp(&other.height)\n    }\n}\n\nimpl PartialOrd for Person {\n    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {\n        Some(self.cmp(other))\n    }\n}\n\nimpl PartialEq for Person {\n    fn eq(&self, other: &Self) -> bool {\n        self.height == other.height\n    }\n}\n```\n\n[`cmp`]: Ord::cmp"          },          filterText = "Ord",          kind = 8,          label = "Ord",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "Ord",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "A generalization of `Clone` to borrowed data.\n\nSome types make it possible to go from borrowed to owned, usually by\nimplementing the `Clone` trait. But `Clone` works only for going from `&T`\nto `T`. The `ToOwned` trait generalizes `Clone` to construct owned data\nfrom any borrow of a given type."          },          filterText = "ToOwned",          kind = 8,          label = "ToOwned",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "ToOwned",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "A contiguous growable array type, written as `Vec<T>`, short for 'vector'.\n\n# Examples\n\n```rust\nlet mut vec = Vec::new();\nvec.push(1);\nvec.push(2);\n\nassert_eq!(vec.len(), 2);\nassert_eq!(vec[0], 1);\n\nassert_eq!(vec.pop(), Some(2));\nassert_eq!(vec.len(), 1);\n\nvec[0] = 7;\nassert_eq!(vec[0], 7);\n\nvec.extend([1, 2, 3].iter().copied());\n\nfor x in &vec {\n    println!(\"{x}\");\n}\nassert_eq!(vec, [7, 1, 2, 3]);\n```\n\nThe [`vec!`] macro is provided for convenient initialization:\n\n```rust\nlet mut vec1 = vec![1, 2, 3];\nvec1.push(4);\nlet vec2 = Vec::from([1, 2, 3, 4]);\nassert_eq!(vec1, vec2);\n```\n\nIt can also initialize each element of a `Vec<T>` with a given value.\nThis may be more efficient than performing allocation and initialization\nin separate steps, especially when initializing a vector of zeros:\n\n```rust\nlet vec = vec![0; 5];\nassert_eq!(vec, [0, 0, 0, 0, 0]);\n\n// The following is equivalent, but potentially slower:\nlet mut vec = Vec::with_capacity(5);\nvec.resize(5, 0);\nassert_eq!(vec, [0, 0, 0, 0, 0]);\n```\n\nFor more information, see\n[Capacity and Reallocation](#capacity-and-reallocation).\n\nUse a `Vec<T>` as an efficient stack:\n\n```rust\nlet mut stack = Vec::new();\n\nstack.push(1);\nstack.push(2);\nstack.push(3);\n\nwhile let Some(top) = stack.pop() {\n    // Prints 3, 2, 1\n    println!(\"{top}\");\n}\n```\n\n# Indexing\n\nThe `Vec` type allows to access values by index, because it implements the\n[`Index`] trait. An example will be more explicit:\n\n```rust\nlet v = vec![0, 2, 4, 6];\nprintln!(\"{}\", v[1]); // it will display '2'\n```\n\nHowever be careful: if you try to access an index which isn't in the `Vec`,\nyour software will panic! You cannot do this:\n\n```rust\nlet v = vec![0, 2, 4, 6];\nprintln!(\"{}\", v[6]); // it will panic!\n```\n\nUse [`get`] and [`get_mut`] if you want to check whether the index is in\nthe `Vec`.\n\n# Slicing\n\nA `Vec` can be mutable. On the other hand, slices are read-only objects.\nTo get a [slice][prim@slice], use [`&`]. Example:\n\n```rust\nfn read_slice(slice: &[usize]) {\n    // ...\n}\n\nlet v = vec![0, 1];\nread_slice(&v);\n\n// ... and that's all!\n// you can also do it like this:\nlet u: &[usize] = &v;\n// or like this:\nlet u: &[_] = &v;\n```\n\nIn Rust, it's more common to pass slices as arguments rather than vectors\nwhen you just want to provide read access. The same goes for [`String`] and\n[`&str`].\n\n# Capacity and reallocation\n\nThe capacity of a vector is the amount of space allocated for any future\nelements that will be added onto the vector. This is not to be confused with\nthe *length* of a vector, which specifies the number of actual elements\nwithin the vector. If a vector's length exceeds its capacity, its capacity\nwill automatically be increased, but its elements will have to be\nreallocated.\n\nFor example, a vector with capacity 10 and length 0 would be an empty vector\nwith space for 10 more elements. Pushing 10 or fewer elements onto the\nvector will not change its capacity or cause reallocation to occur. However,\nif the vector's length is increased to 11, it will have to reallocate, which\ncan be slow. For this reason, it is recommended to use [`Vec::with_capacity`]\nwhenever possible to specify how big the vector is expected to get.\n\n# Guarantees\n\nDue to its incredibly fundamental nature, `Vec` makes a lot of guarantees\nabout its design. This ensures that it's as low-overhead as possible in\nthe general case, and can be correctly manipulated in primitive ways\nby unsafe code. Note that these guarantees refer to an unqualified `Vec<T>`.\nIf additional type parameters are added (e.g., to support custom allocators),\noverriding their defaults may change the behavior.\n\nMost fundamentally, `Vec` is and always will be a (pointer, capacity, length)\ntriplet. No more, no less. The order of these fields is completely\nunspecified, and you should use the appropriate methods to modify these.\nThe pointer will never be null, so this type is null-pointer-optimized.\n\nHowever, the pointer might not actually point to allocated memory. In particular,\nif you construct a `Vec` with capacity 0 via [`Vec::new`], [`vec![]`][`vec!`],\n[`Vec::with_capacity(0)`][`Vec::with_capacity`], or by calling [`shrink_to_fit`]\non an empty Vec, it will not allocate memory. Similarly, if you store zero-sized\ntypes inside a `Vec`, it will not allocate space for them. *Note that in this case\nthe `Vec` might not report a [`capacity`] of 0*. `Vec` will allocate if and only\nif <code>[mem::size_of::\\<T>]\\() * [capacity]\\() > 0</code>. In general, `Vec`'s allocation\ndetails are very subtle --- if you intend to allocate memory using a `Vec`\nand use it for something else (either to pass to unsafe code, or to build your\nown memory-backed collection), be sure to deallocate this memory by using\n`from_raw_parts` to recover the `Vec` and then dropping it.\n\nIf a `Vec` *has* allocated memory, then the memory it points to is on the heap\n(as defined by the allocator Rust is configured to use by default), and its\npointer points to [`len`] initialized, contiguous elements in order (what\nyou would see if you coerced it to a slice), followed by <code>[capacity] - [len]</code>\nlogically uninitialized, contiguous elements.\n\nA vector containing the elements `'a'` and `'b'` with capacity 4 can be\nvisualized as below. The top part is the `Vec` struct, it contains a\npointer to the head of the allocation in the heap, length and capacity.\nThe bottom part is the allocation on the heap, a contiguous memory block.\n\n```text\n            ptr      len  capacity\n       +--------+--------+--------+\n       | 0x0123 |      2 |      4 |\n       +--------+--------+--------+\n            |\n            v\nHeap   +--------+--------+--------+--------+\n       |    'a' |    'b' | uninit | uninit |\n       +--------+--------+--------+--------+\n```\n\n- **uninit** represents memory that is not initialized, see [`MaybeUninit`].\n- Note: the ABI is not stable and `Vec` makes no guarantees about its memory\n  layout (including the order of fields).\n\n`Vec` will never perform a \"small optimization\" where elements are actually\nstored on the stack for two reasons:\n\n* It would make it more difficult for unsafe code to correctly manipulate\n  a `Vec`. The contents of a `Vec` wouldn't have a stable address if it were\n  only moved, and it would be more difficult to determine if a `Vec` had\n  actually allocated memory.\n\n* It would penalize the general case, incurring an additional branch\n  on every access.\n\n`Vec` will never automatically shrink itself, even if completely empty. This\nensures no unnecessary allocations or deallocations occur. Emptying a `Vec`\nand then filling it back up to the same [`len`] should incur no calls to\nthe allocator. If you wish to free up unused memory, use\n[`shrink_to_fit`] or [`shrink_to`].\n\n[`push`] and [`insert`] will never (re)allocate if the reported capacity is\nsufficient. [`push`] and [`insert`] *will* (re)allocate if\n<code>[len] == [capacity]</code>. That is, the reported capacity is completely\naccurate, and can be relied on. It can even be used to manually free the memory\nallocated by a `Vec` if desired. Bulk insertion methods *may* reallocate, even\nwhen not necessary.\n\n`Vec` does not guarantee any particular growth strategy when reallocating\nwhen full, nor when [`reserve`] is called. The current strategy is basic\nand it may prove desirable to use a non-constant growth factor. Whatever\nstrategy is used will of course guarantee *O*(1) amortized [`push`].\n\n`vec![x; n]`, `vec![a, b, c, d]`, and\n[`Vec::with_capacity(n)`][`Vec::with_capacity`], will all produce a `Vec`\nwith exactly the requested capacity. If <code>[len] == [capacity]</code>,\n(as is the case for the [`vec!`] macro), then a `Vec<T>` can be converted to\nand from a [`Box<[T]>`][owned slice] without reallocating or moving the elements.\n\n`Vec` will not specifically overwrite any data that is removed from it,\nbut also won't specifically preserve it. Its uninitialized memory is\nscratch space that it may use however it wants. It will generally just do\nwhatever is most efficient or otherwise easy to implement. Do not rely on\nremoved data to be erased for security purposes. Even if you drop a `Vec`, its\nbuffer may simply be reused by another allocation. Even if you zero a `Vec`'s memory\nfirst, that might not actually happen because the optimizer does not consider\nthis a side-effect that must be preserved. There is one case which we will\nnot break, however: using `unsafe` code to write to the excess capacity,\nand then increasing the length to match, is always valid.\n\nCurrently, `Vec` does not guarantee the order in which elements are dropped.\nThe order has changed in the past and may change again.\n\n[`get`]: ../../std/vec/struct.Vec.html#method.get\n[`get_mut`]: ../../std/vec/struct.Vec.html#method.get_mut\n[`String`]: crate::string::String\n[`&str`]: type@str\n[`shrink_to_fit`]: Vec::shrink_to_fit\n[`shrink_to`]: Vec::shrink_to\n[capacity]: Vec::capacity\n[`capacity`]: Vec::capacity\n[mem::size_of::\\<T>]: core::mem::size_of\n[len]: Vec::len\n[`len`]: Vec::len\n[`push`]: Vec::push\n[`insert`]: Vec::insert\n[`reserve`]: Vec::reserve\n[`MaybeUninit`]: core::mem::MaybeUninit\n[owned slice]: Box"          },          filterText = "Vec",          kind = 22,          label = "Vec",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "Vec",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "The version of the call operator that takes an immutable receiver.\n\nInstances of `Fn` can be called repeatedly without mutating state.\n\n*This trait (`Fn`) is not to be confused with [function pointers]\n(`fn`).*\n\n`Fn` is implemented automatically by closures which only take immutable\nreferences to captured variables or don't capture anything at all, as well\nas (safe) [function pointers] (with some caveats, see their documentation\nfor more details). Additionally, for any type `F` that implements `Fn`, `&F`\nimplements `Fn`, too.\n\nSince both [`FnMut`] and [`FnOnce`] are supertraits of `Fn`, any\ninstance of `Fn` can be used as a parameter where a [`FnMut`] or [`FnOnce`]\nis expected.\n\nUse `Fn` as a bound when you want to accept a parameter of function-like\ntype and need to call it repeatedly and without mutating state (e.g., when\ncalling it concurrently). If you do not need such strict requirements, use\n[`FnMut`] or [`FnOnce`] as bounds.\n\nSee the [chapter on closures in *The Rust Programming Language*][book] for\nsome more information on this topic.\n\nAlso of note is the special syntax for `Fn` traits (e.g.\n`Fn(usize, bool) -> usize`). Those interested in the technical details of\nthis can refer to [the relevant section in the *Rustonomicon*][nomicon].\n\n[book]: ../../book/ch13-01-closures.html\n[function pointers]: fn\n[nomicon]: ../../nomicon/hrtb.html\n\n# Examples\n\n## Calling a closure\n\n```rust\nlet square = |x| x * x;\nassert_eq!(square(5), 25);\n```\n\n## Using a `Fn` parameter\n\n```rust\nfn call_with_one<F>(func: F) -> usize\n    where F: Fn(usize) -> usize {\n    func(1)\n}\n\nlet double = |x| x * 2;\nassert_eq!(call_with_one(double), 2);\n```"          },          filterText = "Fn",          kind = 8,          label = "Fn",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "Fn",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "Conversion into an [`Iterator`].\n\nBy implementing `IntoIterator` for a type, you define how it will be\nconverted to an iterator. This is common for types which describe a\ncollection of some kind.\n\nOne benefit of implementing `IntoIterator` is that your type will [work\nwith Rust's `for` loop syntax](crate::iter#for-loops-and-intoiterator).\n\nSee also: [`FromIterator`].\n\n# Examples\n\nBasic usage:\n\n```rust\nlet v = [1, 2, 3];\nlet mut iter = v.into_iter();\n\nassert_eq!(Some(1), iter.next());\nassert_eq!(Some(2), iter.next());\nassert_eq!(Some(3), iter.next());\nassert_eq!(None, iter.next());\n```\nImplementing `IntoIterator` for your type:\n\n```rust\n// A sample collection, that's just a wrapper over Vec<T>\n#[derive(Debug)]\nstruct MyCollection(Vec<i32>);\n\n// Let's give it some methods so we can create one and add things\n// to it.\nimpl MyCollection {\n    fn new() -> MyCollection {\n        MyCollection(Vec::new())\n    }\n\n    fn add(&mut self, elem: i32) {\n        self.0.push(elem);\n    }\n}\n\n// and we'll implement IntoIterator\nimpl IntoIterator for MyCollection {\n    type Item = i32;\n    type IntoIter = std::vec::IntoIter<Self::Item>;\n\n    fn into_iter(self) -> Self::IntoIter {\n        self.0.into_iter()\n    }\n}\n\n// Now we can make a new collection...\nlet mut c = MyCollection::new();\n\n// ... add some stuff to it ...\nc.add(0);\nc.add(1);\nc.add(2);\n\n// ... and then turn it into an Iterator:\nfor (i, n) in c.into_iter().enumerate() {\n    assert_eq!(i as i32, n);\n}\n```\n\nIt is common to use `IntoIterator` as a trait bound. This allows\nthe input collection type to change, so long as it is still an\niterator. Additional bounds can be specified by restricting on\n`Item`:\n\n```rust\nfn collect_as_strings<T>(collection: T) -> Vec<String>\nwhere\n    T: IntoIterator,\n    T::Item: std::fmt::Debug,\n{\n    collection\n        .into_iter()\n        .map(|item| format!(\"{item:?}\"))\n        .collect()\n}\n```"          },          filterText = "IntoIterator",          kind = 8,          label = "IntoIterator",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "IntoIterator",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "A trait for giving a type a useful default value.\n\nSometimes, you want to fall back to some kind of default value, and\ndon't particularly care what it is. This comes up often with `struct`s\nthat define a set of options:\n\n```rust\nstruct SomeOptions {\n    foo: i32,\n    bar: f32,\n}\n```\n\nHow can we define some default values? You can use `Default`:\n\n```rust\n#[derive(Default)]\nstruct SomeOptions {\n    foo: i32,\n    bar: f32,\n}\n\nfn main() {\n    let options: SomeOptions = Default::default();\n}\n```\n\nNow, you get all of the default values. Rust implements `Default` for various primitives types.\n\nIf you want to override a particular option, but still retain the other defaults:\n\n```rust\nfn main() {\n    let options = SomeOptions { foo: 42, ..Default::default() };\n}\n```\n\n## Derivable\n\nThis trait can be used with `#[derive]` if all of the type's fields implement\n`Default`. When `derive`d, it will use the default value for each field's type.\n\n## How can I implement `Default`?\n\nProvide an implementation for the `default()` method that returns the value of\nyour type that should be the default:\n\n```rust\nenum Kind {\n    A,\n    B,\n    C,\n}\n\nimpl Default for Kind {\n    fn default() -> Self { Kind::A }\n}\n```\n\n# Examples\n\n```rust\n#[derive(Default)]\nstruct SomeOptions {\n    foo: i32,\n    bar: f32,\n}\n```"          },          filterText = "Default",          kind = 8,          label = "Default",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "Default",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "Types with a constant size known at compile time.\n\nAll type parameters have an implicit bound of `Sized`. The special syntax\n`?Sized` can be used to remove this bound if it's not appropriate.\n\n```rust\nstruct Foo<T>(T);\nstruct Bar<T: ?Sized>(T);\n\n// struct FooUse(Foo<[i32]>); // error: Sized is not implemented for [i32]\nstruct BarUse(Bar<[i32]>); // OK\n```\n\nThe one exception is the implicit `Self` type of a trait. A trait does not\nhave an implicit `Sized` bound as this is incompatible with [trait object]s\nwhere, by definition, the trait needs to work with all possible implementors,\nand thus could be any size.\n\nAlthough Rust will let you bind `Sized` to a trait, you won't\nbe able to use it to form a trait object later:\n\n```rust\ntrait Foo { }\ntrait Bar: Sized { }\n\nstruct Impl;\nimpl Foo for Impl { }\nimpl Bar for Impl { }\n\nlet x: &dyn Foo = &Impl;    // OK\n// let y: &dyn Bar = &Impl; // error: the trait `Bar` cannot\n                            // be made into an object\n```\n\n[trait object]: ../../book/ch17-02-trait-objects.html"          },          filterText = "Sized",          kind = 8,          label = "Sized",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "Sized",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "Types for which it is safe to share references between threads.\n\nThis trait is automatically implemented when the compiler determines\nit's appropriate.\n\nThe precise definition is: a type `T` is [`Sync`] if and only if `&T` is\n[`Send`]. In other words, if there is no possibility of\n[undefined behavior][ub] (including data races) when passing\n`&T` references between threads.\n\nAs one would expect, primitive types like [`u8`] and [`f64`]\nare all [`Sync`], and so are simple aggregate types containing them,\nlike tuples, structs and enums. More examples of basic [`Sync`]\ntypes include \"immutable\" types like `&T`, and those with simple\ninherited mutability, such as [`Box<T>`][box], [`Vec<T>`][vec] and\nmost other collection types. (Generic parameters need to be [`Sync`]\nfor their container to be [`Sync`].)\n\nA somewhat surprising consequence of the definition is that `&mut T`\nis `Sync` (if `T` is `Sync`) even though it seems like that might\nprovide unsynchronized mutation. The trick is that a mutable\nreference behind a shared reference (that is, `& &mut T`)\nbecomes read-only, as if it were a `& &T`. Hence there is no risk\nof a data race.\n\nTypes that are not `Sync` are those that have \"interior\nmutability\" in a non-thread-safe form, such as [`Cell`][cell]\nand [`RefCell`][refcell]. These types allow for mutation of\ntheir contents even through an immutable, shared reference. For\nexample the `set` method on [`Cell<T>`][cell] takes `&self`, so it requires\nonly a shared reference [`&Cell<T>`][cell]. The method performs no\nsynchronization, thus [`Cell`][cell] cannot be `Sync`.\n\nAnother example of a non-`Sync` type is the reference-counting\npointer [`Rc`][rc]. Given any reference [`&Rc<T>`][rc], you can clone\na new [`Rc<T>`][rc], modifying the reference counts in a non-atomic way.\n\nFor cases when one does need thread-safe interior mutability,\nRust provides [atomic data types], as well as explicit locking via\n[`sync::Mutex`][mutex] and [`sync::RwLock`][rwlock]. These types\nensure that any mutation cannot cause data races, hence the types\nare `Sync`. Likewise, [`sync::Arc`][arc] provides a thread-safe\nanalogue of [`Rc`][rc].\n\nAny types with interior mutability must also use the\n[`cell::UnsafeCell`][unsafecell] wrapper around the value(s) which\ncan be mutated through a shared reference. Failing to doing this is\n[undefined behavior][ub]. For example, [`transmute`][transmute]-ing\nfrom `&T` to `&mut T` is invalid.\n\nSee [the Nomicon][nomicon-send-and-sync] for more details about `Sync`.\n\n[box]: ../../std/boxed/struct.Box.html\n[vec]: ../../std/vec/struct.Vec.html\n[cell]: crate::cell::Cell\n[refcell]: crate::cell::RefCell\n[rc]: ../../std/rc/struct.Rc.html\n[arc]: ../../std/sync/struct.Arc.html\n[atomic data types]: crate::sync::atomic\n[mutex]: ../../std/sync/struct.Mutex.html\n[rwlock]: ../../std/sync/struct.RwLock.html\n[unsafecell]: crate::cell::UnsafeCell\n[ub]: ../../reference/behavior-considered-undefined.html\n[transmute]: crate::mem::transmute\n[nomicon-send-and-sync]: ../../nomicon/send-and-sync.html"          },          filterText = "Sync",          kind = 8,          label = "Sync",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "Sync",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "An iterator able to yield elements from both ends.\n\nSomething that implements `DoubleEndedIterator` has one extra capability\nover something that implements [`Iterator`]: the ability to also take\n`Item`s from the back, as well as the front.\n\nIt is important to note that both back and forth work on the same range,\nand do not cross: iteration is over when they meet in the middle.\n\nIn a similar fashion to the [`Iterator`] protocol, once a\n`DoubleEndedIterator` returns [`None`] from a [`next_back()`], calling it\nagain may or may not ever return [`Some`] again. [`next()`] and\n[`next_back()`] are interchangeable for this purpose.\n\n[`next_back()`]: DoubleEndedIterator::next_back\n[`next()`]: Iterator::next\n\n# Examples\n\nBasic usage:\n\n```rust\nlet numbers = vec![1, 2, 3, 4, 5, 6];\n\nlet mut iter = numbers.iter();\n\nassert_eq!(Some(&1), iter.next());\nassert_eq!(Some(&6), iter.next_back());\nassert_eq!(Some(&5), iter.next_back());\nassert_eq!(Some(&2), iter.next());\nassert_eq!(Some(&3), iter.next());\nassert_eq!(Some(&4), iter.next());\nassert_eq!(None, iter.next());\nassert_eq!(None, iter.next_back());\n```"          },          filterText = "DoubleEndedIterator",          kind = 8,          label = "DoubleEndedIterator",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "DoubleEndedIterator",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "Some(T)",          documentation = {            kind = "markdown",            value = "Some value of type `T`."          },          filterText = "Some(…)",          insertTextFormat = 2,          kind = 20,          label = "Some(…)",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "Some(${1:()})$0",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          detail = "Err(E)",          documentation = {            kind = "markdown",            value = "Contains the error value"          },          filterText = "Err(…)",          insertTextFormat = 2,          kind = 20,          label = "Err(…)",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "Err(${1:()})$0",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = 'The version of the call operator that takes a by-value receiver.\n\nInstances of `FnOnce` can be called, but might not be callable multiple\ntimes. Because of this, if the only thing known about a type is that it\nimplements `FnOnce`, it can only be called once.\n\n`FnOnce` is implemented automatically by closures that might consume captured\nvariables, as well as all types that implement [`FnMut`], e.g., (safe)\n[function pointers] (since `FnOnce` is a supertrait of [`FnMut`]).\n\nSince both [`Fn`] and [`FnMut`] are subtraits of `FnOnce`, any instance of\n[`Fn`] or [`FnMut`] can be used where a `FnOnce` is expected.\n\nUse `FnOnce` as a bound when you want to accept a parameter of function-like\ntype and only need to call it once. If you need to call the parameter\nrepeatedly, use [`FnMut`] as a bound; if you also need it to not mutate\nstate, use [`Fn`].\n\nSee the [chapter on closures in *The Rust Programming Language*][book] for\nsome more information on this topic.\n\nAlso of note is the special syntax for `Fn` traits (e.g.\n`Fn(usize, bool) -> usize`). Those interested in the technical details of\nthis can refer to [the relevant section in the *Rustonomicon*][nomicon].\n\n[book]: ../../book/ch13-01-closures.html\n[function pointers]: fn\n[nomicon]: ../../nomicon/hrtb.html\n\n# Examples\n\n## Using a `FnOnce` parameter\n\n```rust\nfn consume_with_relish<F>(func: F)\n    where F: FnOnce() -> String\n{\n    // `func` consumes its captured variables, so it cannot be run more\n    // than once.\n    println!("Consumed: {}", func());\n\n    println!("Delicious!");\n\n    // Attempting to invoke `func()` again will throw a `use of moved\n    // value` error for `func`.\n}\n\nlet x = String::from("x");\nlet consume_and_return_x = move || x;\nconsume_with_relish(consume_and_return_x);\n\n// `consume_and_return_x` can no longer be invoked at this point\n```'          },          filterText = "FnOnce",          kind = 8,          label = "FnOnce",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "FnOnce",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "Types that can be transferred across thread boundaries.\n\nThis trait is automatically implemented when the compiler determines it's\nappropriate.\n\nAn example of a non-`Send` type is the reference-counting pointer\n[`rc::Rc`][`Rc`]. If two threads attempt to clone [`Rc`]s that point to the same\nreference-counted value, they might try to update the reference count at the\nsame time, which is [undefined behavior][ub] because [`Rc`] doesn't use atomic\noperations. Its cousin [`sync::Arc`][arc] does use atomic operations (incurring\nsome overhead) and thus is `Send`.\n\nSee [the Nomicon](../../nomicon/send-and-sync.html) for more details.\n\n[`Rc`]: ../../std/rc/struct.Rc.html\n[arc]: ../../std/sync/struct.Arc.html\n[ub]: ../../reference/behavior-considered-undefined.html"          },          filterText = "Send",          kind = 8,          label = "Send",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "Send",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "match",          insertTextFormat = 2,          kind = 14,          label = "match",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "match $1 {\n    $0\n}",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "while",          insertTextFormat = 2,          kind = 14,          label = "while",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "while $1 {\n    $0\n}",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "while let",          insertTextFormat = 2,          kind = 14,          label = "while let",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "while let $1 = $2 {\n    $0\n}",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "loop",          insertTextFormat = 2,          kind = 14,          label = "loop",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "loop {\n    $0\n}",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "if",          insertTextFormat = 2,          kind = 14,          label = "if",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "if $1 {\n    $0\n}",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "if let",          insertTextFormat = 2,          kind = 14,          label = "if let",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "if let $1 = $2 {\n    $0\n}",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "for",          insertTextFormat = 2,          kind = 14,          label = "for",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "for $1 in $2 {\n    $0\n}",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "true",          insertTextFormat = 2,          kind = 14,          label = "true",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "true",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "false",          insertTextFormat = 2,          kind = 14,          label = "false",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "false",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "let",          insertTextFormat = 2,          kind = 14,          label = "let",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "let",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "return",          insertTextFormat = 2,          kind = 14,          label = "return",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "return;",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "pd",          insertTextFormat = 2,          kind = 15,          label = "pd",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = 'eprintln!("$0 = {:?}", $0);',            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "ppd",          insertTextFormat = 2,          kind = 15,          label = "ppd",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = 'eprintln!("$0 = {:#?}", $0);',            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "macro_rules",          insertTextFormat = 2,          kind = 15,          label = "macro_rules",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 5,                line = 5              },              start = {                character = 4,                line = 5              }            },            newText = "macro_rules! $1 {\n    ($2) => {\n        $0\n    };\n}",            replace = {              end = {                character = 11,                line = 5              },              start = {                character = 4,                line = 5              }            }          }        } }    }  }}
[ERROR][2022-06-09 10:08:40] .../vim/lsp/rpc.lua:420	"rpc"	"rust-analyzer"	"stderr"	"Panic context:\n> \nversion: 2022-06-06\nrequest: textDocument/completion CompletionParams {\n    text_document_position: TextDocumentPositionParams {\n        text_document: TextDocumentIdentifier {\n            uri: Url {\n                scheme: \"file\",\n                cannot_be_a_base: false,\n                username: \"\",\n                password: None,\n                host: None,\n                port: None,\n                path: \"/home/jtcf/rustworks/factorio-lib-test/src/main.rs\",\n                query: None,\n                fragment: None,\n            },\n        },\n        position: Position {\n            line: 7,\n            character: 19,\n        },\n    },\n    work_done_progress_params: WorkDoneProgressParams {\n        work_done_token: None,\n    },\n    partial_result_params: PartialResultParams {\n        partial_result_token: None,\n    },\n    context: Some(\n        CompletionContext {\n            trigger_kind: Invoked,\n            trigger_character: None,\n        },\n    ),\n}\n\n> impl_trait_query(ImplId(20626) -> ItemLoc { container: ModuleId { krate: CrateId(31), block: None, local_id: Idx::<ModuleData>(1) }, id: ItemTreeId { tree: TreeId { file: HirFileId(FileId(FileId(305))), block: None }, value: Idx::<Impl>(0) } } -> ImplData { target_trait: Some(TraitRef { path: Path { type_anchor: None, mod_path: ModPath { kind: Plain, segments: [Name(Text(\"fmt\")), Name(Text(\"Debug\"))] }, generic_args: [None, None] } }), self_ty: Path(Path { type_anchor: None, mod_path: ModPath { kind: Plain, segments: [Name(Text(\"SpawnError\"))] }, generic_args: [None] }), items: [FunctionId(FunctionId(29331))], is_negative: false, attribute_calls: None })\n\n> impl_self_ty_query(ImplId(20626) -> ItemLoc { container: ModuleId { krate: CrateId(31), block: None, local_id: Idx::<ModuleData>(1) }, id: ItemTreeId { tree: TreeId { file: HirFileId(FileId(FileId(305))), block: None }, value: Idx::<Impl>(0) } } -> ImplData { target_trait: Some(TraitRef { path: Path { type_anchor: None, mod_path: ModPath { kind: Plain, segments: [Name(Text(\"fmt\")), Name(Text(\"Debug\"))] }, generic_args: [None, None] } }), self_ty: Path(Path { type_anchor: None, mod_path: ModPath { kind: Plain, segments: [Name(Text(\"SpawnError\"))] }, generic_args: [None] }), items: [FunctionId(FunctionId(29331))], is_negative: false, attribute_calls: None })\n\n> DefMap CrateId(31) crate_name=Some(CrateDisplayName { crate_name: CrateName(\"foreign_types_shared\"), canonical_name: \"foreign-types-shared\" }) block=None path=SpawnError\n\nthread 'Worker' panicked at 'index out of bounds: the len is 1 but the index is 1', crates/hir-def/src/nameres/path_resolution.rs:381:33\nstack backtrace:\n"
[ERROR][2022-06-09 10:08:40] .../vim/lsp/rpc.lua:420	"rpc"	"rust-analyzer"	"stderr"	"note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.\n"
[ERROR][2022-06-09 10:08:40] .../vim/lsp/rpc.lua:534	"No callback found for server response id 73"
[ERROR][2022-06-09 10:08:40] .../lua/vim/lsp.lua:824	"LSP[rust_analyzer]"	"on_error"	{  code = "NO_RESULT_CALLBACK_FOUND",  err = {    error = {      code = -32603,      message = "request handler panicked: index out of bounds: the len is 1 but the index is 1"    },    id = 73,    jsonrpc = "2.0"  }}
[ERROR][2022-06-09 10:08:40] .../vim/lsp/rpc.lua:420	"rpc"	"rust-analyzer"	"stderr"	"Panic context:\n> \nversion: 2022-06-06\nrequest: textDocument/completion CompletionParams {\n    text_document_position: TextDocumentPositionParams {\n        text_document: TextDocumentIdentifier {\n            uri: Url {\n                scheme: \"file\",\n                cannot_be_a_base: false,\n                username: \"\",\n                password: None,\n                host: None,\n                port: None,\n                path: \"/home/jtcf/rustworks/factorio-lib-test/src/main.rs\",\n                query: None,\n                fragment: None,\n            },\n        },\n        position: Position {\n            line: 7,\n            character: 24,\n        },\n    },\n    work_done_progress_params: WorkDoneProgressParams {\n        work_done_token: None,\n    },\n    partial_result_params: PartialResultParams {\n        partial_result_token: None,\n    },\n    context: Some(\n        CompletionContext {\n            trigger_kind: Invoked,\n            trigger_character: None,\n        },\n    ),\n}\n\n> impl_trait_query(ImplId(20626) -> ItemLoc { container: ModuleId { krate: CrateId(31), block: None, local_id: Idx::<ModuleData>(1) }, id: ItemTreeId { tree: TreeId { file: HirFileId(FileId(FileId(305))), block: None }, value: Idx::<Impl>(0) } } -> ImplData { target_trait: Some(TraitRef { path: Path { type_anchor: None, mod_path: ModPath { kind: Plain, segments: [Name(Text(\"fmt\")), Name(Text(\"Debug\"))] }, generic_args: [None, None] } }), self_ty: Path(Path { type_anchor: None, mod_path: ModPath { kind: Plain, segments: [Name(Text(\"SpawnError\"))] }, generic_args: [None] }), items: [FunctionId(FunctionId(29331))], is_negative: false, attribute_calls: None })\n\n> impl_self_ty_query(ImplId(20626) -> ItemLoc { container: ModuleId { krate: CrateId(31), block: None, local_id: Idx::<ModuleData>(1) }, id: ItemTreeId { tree: TreeId { file: HirFileId(FileId(FileId(305))), block: None }, value: Idx::<Impl>(0) } } -> ImplData { target_trait: Some(TraitRef { path: Path { type_anchor: None, mod_path: ModPath { kind: Plain, segments: [Name(Text(\"fmt\")), Name(Text(\"Debug\"))] }, generic_args: [None, None] } }), self_ty: Path(Path { type_anchor: None, mod_path: ModPath { kind: Plain, segments: [Name(Text(\"SpawnError\"))] }, generic_args: [None] }), items: [FunctionId(FunctionId(29331))], is_negative: false, attribute_calls: None })\n\n> DefMap CrateId(31) crate_name=Some(CrateDisplayName { crate_name: CrateName(\"foreign_types_shared\"), canonical_name: \"foreign-types-shared\" }) block=None path=SpawnError\n\nthread 'Worker' panicked at 'index out of bounds: the len is 1 but the index is 1', crates/hir-def/src/nameres/path_resolution.rs:381:33\nstack backtrace:\nnote: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.\n"
[ERROR][2022-06-09 10:08:42] .../vim/lsp/rpc.lua:420	"rpc"	"rust-analyzer"	"stderr"	"Panic context:\n> \nversion: 2022-06-06\nrequest: textDocument/completion CompletionParams {\n    text_document_position: TextDocumentPositionParams {\n        text_document: TextDocumentIdentifier {\n            uri: Url {\n                scheme: \"file\",\n                cannot_be_a_base: false,\n                username: \"\",\n                password: None,\n                host: None,\n                port: None,\n                path: \"/home/jtcf/rustworks/factorio-lib-test/src/main.rs\",\n                query: None,\n                fragment: None,\n            },\n        },\n        position: Position {\n            line: 7,\n            character: 31,\n        },\n    },\n    work_done_progress_params: WorkDoneProgressParams {\n        work_done_token: None,\n    },\n    partial_result_params: PartialResultParams {\n        partial_result_token: None,\n    },\n    context: Some(\n        CompletionContext {\n            trigger_kind: TriggerCharacter,\n            trigger_character: Some(\n                \"(\",\n            ),\n        },\n    ),\n}\n\n> impl_trait_query(ImplId(20626) -> ItemLoc { container: ModuleId { krate: CrateId(31), block: None, local_id: Idx::<ModuleData>(1) }, id: ItemTreeId { tree: TreeId { file: HirFileId(FileId(FileId(305))), block: None }, value: Idx::<Impl>(0) } } -> ImplData { target_trait: Some(TraitRef { path: Path { type_anchor: None, mod_path: ModPath { kind: Plain, segments: [Name(Text(\"fmt\")), Name(Text(\"Debug\"))] }, generic_args: [None, None] } }), self_ty: Path(Path { type_anchor: None, mod_path: ModPath { kind: Plain, segments: [Name(Text(\"SpawnError\"))] }, generic_args: [None] }), items: [FunctionId(FunctionId(29331))], is_negative: false, attribute_calls: None })\n\n> impl_self_ty_query(ImplId(20626) -> ItemLoc { container: ModuleId { krate: CrateId(31), block: None, local_id: Idx::<ModuleData>(1) }, id: ItemTreeId { tree: TreeId { file: HirFileId(FileId(FileId(305))), block: None }, value: Idx::<Impl>(0) } } -> ImplData { target_trait: Some(TraitRef { path: Path { type_anchor: None, mod_path: ModPath { kind: Plain, segments: [Name(Text(\"fmt\")), Name(Text(\"Debug\"))] }, generic_args: [None, None] } }), self_ty: Path(Path { type_anchor: None, mod_path: ModPath { kind: Plain, segments: [Name(Text(\"SpawnError\"))] }, generic_args: [None] }), items: [FunctionId(FunctionId(29331))], is_negative: false, attribute_calls: None })\n\n> DefMap CrateId(31) crate_name=Some(CrateDisplayName { crate_name: CrateName(\"foreign_types_shared\"), canonical_name: \"foreign-types-shared\" }) block=None path=SpawnError\n\nthread 'Worker' panicked at 'index out of bounds: the len is 1 but the index is 1', crates/hir-def/src/nameres/path_resolution.rs:381:33\nstack backtrace:\nnote: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.\n"
[ERROR][2022-06-09 10:08:51] .../vim/lsp/rpc.lua:420	"rpc"	"rust-analyzer"	"stderr"	"Panic context:\n> impl_trait_query(ImplId(20626) -> ItemLoc { container: ModuleId { krate: CrateId(31), block: None, local_id: Idx::<ModuleData>(1) }, id: ItemTreeId { tree: TreeId { file: HirFileId(FileId(FileId(305))), block: None }, value: Idx::<Impl>(0) } } -> ImplData { target_trait: Some(TraitRef { path: Path { type_anchor: None, mod_path: ModPath { kind: Plain, segments: [Name(Text(\"fmt\")), Name(Text(\"Debug\"))] }, generic_args: [None, None] } }), self_ty: Path(Path { type_anchor: None, mod_path: ModPath { kind: Plain, segments: [Name(Text(\"SpawnError\"))] }, generic_args: [None] }), items: [FunctionId(FunctionId(29331))], is_negative: false, attribute_calls: None })\n\n> impl_self_ty_query(ImplId(20626) -> ItemLoc { container: ModuleId { krate: CrateId(31), block: None, local_id: Idx::<ModuleData>(1) }, id: ItemTreeId { tree: TreeId { file: HirFileId(FileId(FileId(305))), block: None }, value: Idx::<Impl>(0) } } -> ImplData { target_trait: Some(TraitRef { path: Path { type_anchor: None, mod_path: ModPath { kind: Plain, segments: [Name(Text(\"fmt\")), Name(Text(\"Debug\"))] }, generic_args: [None, None] } }), self_ty: Path(Path { type_anchor: None, mod_path: ModPath { kind: Plain, segments: [Name(Text(\"SpawnError\"))] }, generic_args: [None] }), items: [FunctionId(FunctionId(29331))], is_negative: false, attribute_calls: None })\n\n> DefMap CrateId(31) crate_name=Some(CrateDisplayName { crate_name: CrateName(\"foreign_types_shared\"), canonical_name: \"foreign-types-shared\" }) block=None path=SpawnError\n\nthread 'Worker' panicked at 'index out of bounds: the len is 1 but the index is 1', crates/hir-def/src/nameres/path_resolution.rs:381:33\nstack backtrace:\n"
[ERROR][2022-06-09 10:08:51] .../vim/lsp/rpc.lua:420	"rpc"	"rust-analyzer"	"stderr"	"note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.\n"
[ERROR][2022-06-09 10:08:52] .../vim/lsp/rpc.lua:420	"rpc"	"rust-analyzer"	"stderr"	"Panic context:\n> \nversion: 2022-06-06\nrequest: textDocument/completion CompletionParams {\n    text_document_position: TextDocumentPositionParams {\n        text_document: TextDocumentIdentifier {\n            uri: Url {\n                scheme: \"file\",\n                cannot_be_a_base: false,\n                username: \"\",\n                password: None,\n                host: None,\n                port: None,\n                path: \"/home/jtcf/rustworks/factorio-lib-test/src/main.rs\",\n                query: None,\n                fragment: None,\n            },\n        },\n        position: Position {\n            line: 7,\n            character: 28,\n        },\n    },\n    work_done_progress_params: WorkDoneProgressParams {\n        work_done_token: None,\n    },\n    partial_result_params: PartialResultParams {\n        partial_result_token: None,\n    },\n    context: Some(\n        CompletionContext {\n            trigger_kind: Invoked,\n            trigger_character: None,\n        },\n    ),\n}\n\n> impl_trait_query(ImplId(22625) -> ItemLoc { container: ModuleId { krate: CrateId(100), block: None, local_id: Idx::<ModuleData>(1) }, id: ItemTreeId { tree: TreeId { file: HirFileId(FileId(FileId(1855))), block: None }, value: Idx::<Impl>(0) } } -> ImplData { target_trait: None, self_ty: Path(Path { type_anchor: None, mod_path: ModPath { kind: Plain, segments: [Name(Text(\"Registry\"))] }, generic_args: [None] }), items: [FunctionId(FunctionId(38085)), FunctionId(FunctionId(38086))], is_negative: false, attribute_calls: None })\n\n> impl_self_ty_query(ImplId(22625) -> ItemLoc { container: ModuleId { krate: CrateId(100), block: None, local_id: Idx::<ModuleData>(1) }, id: ItemTreeId { tree: TreeId { file: HirFileId(FileId(FileId(1855))), block: None }, value: Idx::<Impl>(0) } } -> ImplData { target_trait: None, self_ty: Path(Path { type_anchor: None, mod_path: ModPath { kind: Plain, segments: [Name(Text(\"Registry\"))] }, generic_args: [None] }), items: [FunctionId(FunctionId(38085)), FunctionId(FunctionId(38086))], is_negative: false, attribute_calls: None })\n\n> DefMap CrateId(100) crate_name=Some(CrateDisplayName { crate_name: CrateName(\"tinyvec_macros\"), canonical_name: \"tinyvec_macros\" }) block=None path=Registry\n\nthread 'Worker' panicked at 'index out of bounds: the len is 1 but the index is 1', crates/hir-def/src/nameres/path_resolution.rs:381:33\nstack backtrace:\n"
[ERROR][2022-06-09 10:08:52] .../vim/lsp/rpc.lua:420	"rpc"	"rust-analyzer"	"stderr"	"note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.\n"
[ERROR][2022-06-09 10:08:52] .../vim/lsp/rpc.lua:534	"No callback found for server response id 85"
[ERROR][2022-06-09 10:08:52] .../lua/vim/lsp.lua:824	"LSP[rust_analyzer]"	"on_error"	{  code = "NO_RESULT_CALLBACK_FOUND",  err = {    error = {      code = -32603,      message = "request handler panicked: index out of bounds: the len is 1 but the index is 1"    },    id = 85,    jsonrpc = "2.0"  }}
[START][2022-06-09 12:03:07] LSP logging initiated
[ERROR][2022-06-09 12:03:59] .../vim/lsp/rpc.lua:534	"No callback found for server response id 14"
[ERROR][2022-06-09 12:03:59] .../lua/vim/lsp.lua:824	"LSP[rust_analyzer]"	"on_error"	{  code = "NO_RESULT_CALLBACK_FOUND",  err = {    id = 14,    jsonrpc = "2.0",    result = {      isIncomplete = true,      items = { {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "Utilities for formatting and printing `String`s.\n\nThis module contains the runtime support for the [`format!`] syntax extension.\nThis macro is implemented in the compiler to emit calls to this module in\norder to format arguments at runtime into strings.\n\n# Usage\n\nThe [`format!`] macro is intended to be familiar to those coming from C's\n`printf`/`fprintf` functions or Python's `str.format` function.\n\nSome examples of the [`format!`] extension are:\n\n```rust\nformat!(\"Hello\");                 // => \"Hello\"\nformat!(\"Hello, {}!\", \"world\");   // => \"Hello, world!\"\nformat!(\"The number is {}\", 1);   // => \"The number is 1\"\nformat!(\"{:?}\", (3, 4));          // => \"(3, 4)\"\nformat!(\"{value}\", value=4);      // => \"4\"\nlet people = \"Rustaceans\";\nformat!(\"Hello {people}!\");       // => \"Hello Rustaceans!\"\nformat!(\"{} {}\", 1, 2);           // => \"1 2\"\nformat!(\"{:04}\", 42);             // => \"0042\" with leading zeros\nformat!(\"{:#?}\", (100, 200));     // => \"(\n                                  //       100,\n                                  //       200,\n                                  //     )\"\n```\n\nFrom these, you can see that the first argument is a format string. It is\nrequired by the compiler for this to be a string literal; it cannot be a\nvariable passed in (in order to perform validity checking). The compiler\nwill then parse the format string and determine if the list of arguments\nprovided is suitable to pass to this format string.\n\nTo convert a single value to a string, use the [`to_string`] method. This\nwill use the [`Display`] formatting trait.\n\n## Positional parameters\n\nEach formatting argument is allowed to specify which value argument it's\nreferencing, and if omitted it is assumed to be \"the next argument\". For\nexample, the format string `{} {} {}` would take three parameters, and they\nwould be formatted in the same order as they're given. The format string\n`{2} {1} {0}`, however, would format arguments in reverse order.\n\nThings can get a little tricky once you start intermingling the two types of\npositional specifiers. The \"next argument\" specifier can be thought of as an\niterator over the argument. Each time a \"next argument\" specifier is seen,\nthe iterator advances. This leads to behavior like this:\n\n```rust\nformat!(\"{1} {} {0} {}\", 1, 2); // => \"2 1 1 2\"\n```\n\nThe internal iterator over the argument has not been advanced by the time\nthe first `{}` is seen, so it prints the first argument. Then upon reaching\nthe second `{}`, the iterator has advanced forward to the second argument.\nEssentially, parameters that explicitly name their argument do not affect\nparameters that do not name an argument in terms of positional specifiers.\n\nA format string is required to use all of its arguments, otherwise it is a\ncompile-time error. You may refer to the same argument more than once in the\nformat string.\n\n## Named parameters\n\nRust itself does not have a Python-like equivalent of named parameters to a\nfunction, but the [`format!`] macro is a syntax extension that allows it to\nleverage named parameters. Named parameters are listed at the end of the\nargument list and have the syntax:\n\n```text\nidentifier '=' expression\n```\n\nFor example, the following [`format!`] expressions all use named arguments:\n\n```rust\nformat!(\"{argument}\", argument = \"test\");   // => \"test\"\nformat!(\"{name} {}\", 1, name = 2);          // => \"2 1\"\nformat!(\"{a} {c} {b}\", a=\"a\", b='b', c=3);  // => \"a 3 b\"\n```\n\nIf a named parameter does not appear in the argument list, `format!` will\nreference a variable with that name in the current scope.\n\n```rust\nlet argument = 2 + 2;\nformat!(\"{argument}\");   // => \"4\"\n\nfn make_string(a: u32, b: &str) -> String {\n    format!(\"{b} {a}\")\n}\nmake_string(927, \"label\"); // => \"label 927\"\n```\n\nIt is not valid to put positional parameters (those without names) after\narguments that have names. Like with positional parameters, it is not\nvalid to provide named parameters that are unused by the format string.\n\n# Formatting Parameters\n\nEach argument being formatted can be transformed by a number of formatting\nparameters (corresponding to `format_spec` in [the syntax](#syntax)). These\nparameters affect the string representation of what's being formatted.\n\n## Width\n\n```rust\n// All of these print \"Hello x    !\"\nprintln!(\"Hello {:5}!\", \"x\");\nprintln!(\"Hello {:1$}!\", \"x\", 5);\nprintln!(\"Hello {1:0$}!\", 5, \"x\");\nprintln!(\"Hello {:width$}!\", \"x\", width = 5);\nlet width = 5;\nprintln!(\"Hello {:width$}!\", \"x\");\n```\n\nThis is a parameter for the \"minimum width\" that the format should take up.\nIf the value's string does not fill up this many characters, then the\npadding specified by fill/alignment will be used to take up the required\nspace (see below).\n\nThe value for the width can also be provided as a [`usize`] in the list of\nparameters by adding a postfix `$`, indicating that the second argument is\na [`usize`] specifying the width.\n\nReferring to an argument with the dollar syntax does not affect the \"next\nargument\" counter, so it's usually a good idea to refer to arguments by\nposition, or use named arguments.\n\n## Fill/Alignment\n\n```rust\nassert_eq!(format!(\"Hello {:<5}!\", \"x\"),  \"Hello x    !\");\nassert_eq!(format!(\"Hello {:-<5}!\", \"x\"), \"Hello x----!\");\nassert_eq!(format!(\"Hello {:^5}!\", \"x\"),  \"Hello   x  !\");\nassert_eq!(format!(\"Hello {:>5}!\", \"x\"),  \"Hello     x!\");\n```\n\nThe optional fill character and alignment is provided normally in conjunction with the\n[`width`](#width) parameter. It must be defined before `width`, right after the `:`.\nThis indicates that if the value being formatted is smaller than\n`width` some extra characters will be printed around it.\nFilling comes in the following variants for different alignments:\n\n* `[fill]<` - the argument is left-aligned in `width` columns\n* `[fill]^` - the argument is center-aligned in `width` columns\n* `[fill]>` - the argument is right-aligned in `width` columns\n\nThe default [fill/alignment](#fillalignment) for non-numerics is a space and\nleft-aligned. The\ndefault for numeric formatters is also a space character but with right-alignment. If\nthe `0` flag (see below) is specified for numerics, then the implicit fill character is\n`0`.\n\nNote that alignment might not be implemented by some types. In particular, it\nis not generally implemented for the `Debug` trait.  A good way to ensure\npadding is applied is to format your input, then pad this resulting string\nto obtain your output:\n\n```rust\nprintln!(\"Hello {:^15}!\", format!(\"{:?}\", Some(\"hi\"))); // => \"Hello   Some(\"hi\")   !\"\n```\n\n## Sign/`#`/`0`\n\n```rust\nassert_eq!(format!(\"Hello {:+}!\", 5), \"Hello +5!\");\nassert_eq!(format!(\"{:#x}!\", 27), \"0x1b!\");\nassert_eq!(format!(\"Hello {:05}!\", 5),  \"Hello 00005!\");\nassert_eq!(format!(\"Hello {:05}!\", -5), \"Hello -0005!\");\nassert_eq!(format!(\"{:#010x}!\", 27), \"0x0000001b!\");\n```\n\nThese are all flags altering the behavior of the formatter.\n\n* `+` - This is intended for numeric types and indicates that the sign\n        should always be printed. Positive signs are never printed by\n        default, and the negative sign is only printed by default for signed values.\n        This flag indicates that the correct sign (`+` or `-`) should always be printed.\n* `-` - Currently not used\n* `#` - This flag indicates that the \"alternate\" form of printing should\n        be used. The alternate forms are:\n    * `#?` - pretty-print the [`Debug`] formatting (adds linebreaks and indentation)\n    * `#x` - precedes the argument with a `0x`\n    * `#X` - precedes the argument with a `0x`\n    * `#b` - precedes the argument with a `0b`\n    * `#o` - precedes the argument with a `0o`\n* `0` - This is used to indicate for integer formats that the padding to `width` should\n        both be done with a `0` character as well as be sign-aware. A format\n        like `{:08}` would yield `00000001` for the integer `1`, while the\n        same format would yield `-0000001` for the integer `-1`. Notice that\n        the negative version has one fewer zero than the positive version.\n        Note that padding zeros are always placed after the sign (if any)\n        and before the digits. When used together with the `#` flag, a similar\n        rule applies: padding zeros are inserted after the prefix but before\n        the digits. The prefix is included in the total width.\n\n## Precision\n\nFor non-numeric types, this can be considered a \"maximum width\". If the resulting string is\nlonger than this width, then it is truncated down to this many characters and that truncated\nvalue is emitted with proper `fill`, `alignment` and `width` if those parameters are set.\n\nFor integral types, this is ignored.\n\nFor floating-point types, this indicates how many digits after the decimal point should be\nprinted.\n\nThere are three possible ways to specify the desired `precision`:\n\n1. An integer `.N`:\n\n   the integer `N` itself is the precision.\n\n2. An integer or name followed by dollar sign `.N$`:\n\n   use format *argument* `N` (which must be a `usize`) as the precision.\n\n3. An asterisk `.*`:\n\n   `.*` means that this `{...}` is associated with *two* format inputs rather than one: the\n   first input holds the `usize` precision, and the second holds the value to print. Note that\n   in this case, if one uses the format string `{<arg>:<spec>.*}`, then the `<arg>` part refers\n   to the *value* to print, and the `precision` must come in the input preceding `<arg>`.\n\nFor example, the following calls all print the same thing `Hello x is 0.01000`:\n\n```rust\n// Hello {arg 0 (\"x\")} is {arg 1 (0.01) with precision specified inline (5)}\nprintln!(\"Hello {0} is {1:.5}\", \"x\", 0.01);\n\n// Hello {arg 1 (\"x\")} is {arg 2 (0.01) with precision specified in arg 0 (5)}\nprintln!(\"Hello {1} is {2:.0$}\", 5, \"x\", 0.01);\n\n// Hello {arg 0 (\"x\")} is {arg 2 (0.01) with precision specified in arg 1 (5)}\nprintln!(\"Hello {0} is {2:.1$}\", \"x\", 5, 0.01);\n\n// Hello {next arg (\"x\")} is {second of next two args (0.01) with precision\n//                          specified in first of next two args (5)}\nprintln!(\"Hello {} is {:.*}\",    \"x\", 5, 0.01);\n\n// Hello {next arg (\"x\")} is {arg 2 (0.01) with precision\n//                          specified in its predecessor (5)}\nprintln!(\"Hello {} is {2:.*}\",   \"x\", 5, 0.01);\n\n// Hello {next arg (\"x\")} is {arg \"number\" (0.01) with precision specified\n//                          in arg \"prec\" (5)}\nprintln!(\"Hello {} is {number:.prec$}\", \"x\", prec = 5, number = 0.01);\n```\n\nWhile these:\n\n```rust\nprintln!(\"{}, `{name:.*}` has 3 fractional digits\", \"Hello\", 3, name=1234.56);\nprintln!(\"{}, `{name:.*}` has 3 characters\", \"Hello\", 3, name=\"1234.56\");\nprintln!(\"{}, `{name:>8.*}` has 3 right-aligned characters\", \"Hello\", 3, name=\"1234.56\");\n```\n\nprint three significantly different things:\n\n```text\nHello, `1234.560` has 3 fractional digits\nHello, `123` has 3 characters\nHello, `     123` has 3 right-aligned characters\n```\n\n## Localization\n\nIn some programming languages, the behavior of string formatting functions\ndepends on the operating system's locale setting. The format functions\nprovided by Rust's standard library do not have any concept of locale and\nwill produce the same results on all systems regardless of user\nconfiguration.\n\nFor example, the following code will always print `1.5` even if the system\nlocale uses a decimal separator other than a dot.\n\n```rust\nprintln!(\"The value is {}\", 1.5);\n```\n\n# Escaping\n\nThe literal characters `{` and `}` may be included in a string by preceding\nthem with the same character. For example, the `{` character is escaped with\n`{{` and the `}` character is escaped with `}}`.\n\n```rust\nassert_eq!(format!(\"Hello {{}}\"), \"Hello {}\");\nassert_eq!(format!(\"{{ Hello\"), \"{ Hello\");\n```\n\n# Syntax\n\nTo summarize, here you can find the full grammar of format strings.\nThe syntax for the formatting language used is drawn from other languages,\nso it should not be too alien. Arguments are formatted with Python-like\nsyntax, meaning that arguments are surrounded by `{}` instead of the C-like\n`%`. The actual grammar for the formatting syntax is:\n\n```text\nformat_string := text [ maybe_format text ] *\nmaybe_format := '{' '{' | '}' '}' | format\nformat := '{' [ argument ] [ ':' format_spec ] '}'\nargument := integer | identifier\n\nformat_spec := [[fill]align][sign]['#']['0'][width]['.' precision]type\nfill := character\nalign := '<' | '^' | '>'\nsign := '+' | '-'\nwidth := count\nprecision := count | '*'\ntype := '' | '?' | 'x?' | 'X?' | identifier\ncount := parameter | integer\nparameter := argument '$'\n```\nIn the above grammar, `text` must not contain any `'{'` or `'}'` characters.\n\n# Formatting traits\n\nWhen requesting that an argument be formatted with a particular type, you\nare actually requesting that an argument ascribes to a particular trait.\nThis allows multiple actual types to be formatted via `{:x}` (like [`i8`] as\nwell as [`isize`]). The current mapping of types to traits is:\n\n* *nothing* ⇒ [`Display`]\n* `?` ⇒ [`Debug`]\n* `x?` ⇒ [`Debug`] with lower-case hexadecimal integers\n* `X?` ⇒ [`Debug`] with upper-case hexadecimal integers\n* `o` ⇒ [`Octal`]\n* `x` ⇒ [`LowerHex`]\n* `X` ⇒ [`UpperHex`]\n* `p` ⇒ [`Pointer`]\n* `b` ⇒ [`Binary`]\n* `e` ⇒ [`LowerExp`]\n* `E` ⇒ [`UpperExp`]\n\nWhat this means is that any type of argument which implements the\n[`fmt::Binary`][`Binary`] trait can then be formatted with `{:b}`. Implementations\nare provided for these traits for a number of primitive types by the\nstandard library as well. If no format is specified (as in `{}` or `{:6}`),\nthen the format trait used is the [`Display`] trait.\n\nWhen implementing a format trait for your own type, you will have to\nimplement a method of the signature:\n\n```rust\nfn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n```\n\nYour type will be passed as `self` by-reference, and then the function\nshould emit output into the `f.buf` stream. It is up to each format trait\nimplementation to correctly adhere to the requested formatting parameters.\nThe values of these parameters will be listed in the fields of the\n[`Formatter`] struct. In order to help with this, the [`Formatter`] struct also\nprovides some helper methods.\n\nAdditionally, the return value of this function is [`fmt::Result`] which is a\ntype alias of <code>[Result]<(), [std::fmt::Error]></code>. Formatting implementations\nshould ensure that they propagate errors from the [`Formatter`] (e.g., when\ncalling [`write!`]). However, they should never return errors spuriously. That\nis, a formatting implementation must and may only return an error if the\npassed-in [`Formatter`] returns an error. This is because, contrary to what\nthe function signature might suggest, string formatting is an infallible\noperation. This function only returns a result because writing to the\nunderlying stream might fail and it must provide a way to propagate the fact\nthat an error has occurred back up the stack.\n\nAn example of implementing the formatting traits would look\nlike:\n\n```rust\nuse std::fmt;\n\n#[derive(Debug)]\nstruct Vector2D {\n    x: isize,\n    y: isize,\n}\n\nimpl fmt::Display for Vector2D {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        // The `f` value implements the `Write` trait, which is what the\n        // write! macro is expecting. Note that this formatting ignores the\n        // various flags provided to format strings.\n        write!(f, \"({}, {})\", self.x, self.y)\n    }\n}\n\n// Different traits allow different forms of output of a type. The meaning\n// of this format is to print the magnitude of a vector.\nimpl fmt::Binary for Vector2D {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        let magnitude = (self.x * self.x + self.y * self.y) as f64;\n        let magnitude = magnitude.sqrt();\n\n        // Respect the formatting flags by using the helper method\n        // `pad_integral` on the Formatter object. See the method\n        // documentation for details, and the function `pad` can be used\n        // to pad strings.\n        let decimals = f.precision().unwrap_or(3);\n        let string = format!(\"{:.*}\", decimals, magnitude);\n        f.pad_integral(true, \"\", &string)\n    }\n}\n\nfn main() {\n    let myvector = Vector2D { x: 3, y: 4 };\n\n    println!(\"{myvector}\");       // => \"(3, 4)\"\n    println!(\"{myvector:?}\");     // => \"Vector2D {x: 3, y:4}\"\n    println!(\"{myvector:10.3b}\"); // => \"     5.000\"\n}\n```\n\n### `fmt::Display` vs `fmt::Debug`\n\nThese two formatting traits have distinct purposes:\n\n- [`fmt::Display`][`Display`] implementations assert that the type can be faithfully\n  represented as a UTF-8 string at all times. It is **not** expected that\n  all types implement the [`Display`] trait.\n- [`fmt::Debug`][`Debug`] implementations should be implemented for **all** public types.\n  Output will typically represent the internal state as faithfully as possible.\n  The purpose of the [`Debug`] trait is to facilitate debugging Rust code. In\n  most cases, using `#[derive(Debug)]` is sufficient and recommended.\n\nSome examples of the output from both traits:\n\n```rust\nassert_eq!(format!(\"{} {:?}\", 3, 4), \"3 4\");\nassert_eq!(format!(\"{} {:?}\", 'a', 'b'), \"a 'b'\");\nassert_eq!(format!(\"{} {:?}\", \"foo\\n\", \"bar\\n\"), \"foo\\n \\\"bar\\\\n\\\"\");\n```\n\n# Related macros\n\nThere are a number of related macros in the [`format!`] family. The ones that\nare currently implemented are:\n\n```rust\nformat!      // described above\nwrite!       // first argument is a &mut io::Write, the destination\nwriteln!     // same as write but appends a newline\nprint!       // the format string is printed to the standard output\nprintln!     // same as print but appends a newline\neprint!      // the format string is printed to the standard error\neprintln!    // same as eprint but appends a newline\nformat_args! // described below.\n```\n\n### `write!`\n\nThis and [`writeln!`] are two macros which are used to emit the format string\nto a specified stream. This is used to prevent intermediate allocations of\nformat strings and instead directly write the output. Under the hood, this\nfunction is actually invoking the [`write_fmt`] function defined on the\n[`std::io::Write`] trait. Example usage is:\n\n```rust\nuse std::io::Write;\nlet mut w = Vec::new();\nwrite!(&mut w, \"Hello {}!\", \"world\");\n```\n\n### `print!`\n\nThis and [`println!`] emit their output to stdout. Similarly to the [`write!`]\nmacro, the goal of these macros is to avoid intermediate allocations when\nprinting output. Example usage is:\n\n```rust\nprint!(\"Hello {}!\", \"world\");\nprintln!(\"I have a newline {}\", \"character at the end\");\n```\n### `eprint!`\n\nThe [`eprint!`] and [`eprintln!`] macros are identical to\n[`print!`] and [`println!`], respectively, except they emit their\noutput to stderr.\n\n### `format_args!`\n\nThis is a curious macro used to safely pass around\nan opaque object describing the format string. This object\ndoes not require any heap allocations to create, and it only\nreferences information on the stack. Under the hood, all of\nthe related macros are implemented in terms of this. First\noff, some example usage is:\n\n```rust\nuse std::fmt;\nuse std::io::{self, Write};\n\nlet mut some_writer = io::stdout();\nwrite!(&mut some_writer, \"{}\", format_args!(\"print with a {}\", \"macro\"));\n\nfn my_fmt_fn(args: fmt::Arguments) {\n    write!(&mut io::stdout(), \"{}\", args);\n}\nmy_fmt_fn(format_args!(\", or a {} too\", \"function\"));\n```\n\nThe result of the [`format_args!`] macro is a value of type [`fmt::Arguments`].\nThis structure can then be passed to the [`write`] and [`format`] functions\ninside this module in order to process the format string.\nThe goal of this macro is to even further prevent intermediate allocations\nwhen dealing with formatting strings.\n\nFor example, a logging library could use the standard formatting syntax, but\nit would internally pass around this structure until it has been determined\nwhere output should go to.\n\n[`fmt::Result`]: Result \"fmt::Result\"\n[Result]: core::result::Result \"std::result::Result\"\n[std::fmt::Error]: Error \"fmt::Error\"\n[`write`]: write() \"fmt::write\"\n[`to_string`]: crate::string::ToString::to_string \"ToString::to_string\"\n[`write_fmt`]: ../../std/io/trait.Write.html#method.write_fmt\n[`std::io::Write`]: ../../std/io/trait.Write.html\n[`print!`]: ../../std/macro.print.html \"print!\"\n[`println!`]: ../../std/macro.println.html \"println!\"\n[`eprint!`]: ../../std/macro.eprint.html \"eprint!\"\n[`eprintln!`]: ../../std/macro.eprintln.html \"eprintln!\"\n[`fmt::Arguments`]: Arguments \"fmt::Arguments\"\n[`format`]: format() \"fmt::format\""          },          filterText = "fmt",          kind = 9,          label = "fmt",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2962              },              start = {                character = 6,                line = 2962              }            },            newText = "fmt",            replace = {              end = {                character = 13,                line = 2962              },              start = {                character = 6,                line = 2962              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "abstract_prototypes",          kind = 9,          label = "abstract_prototypes",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2962              },              start = {                character = 6,                line = 2962              }            },            newText = "abstract_prototypes",            replace = {              end = {                character = 13,                line = 2962              },              start = {                character = 6,                line = 2962              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "prototype_type",          kind = 9,          label = "prototype_type",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2962              },              start = {                character = 6,                line = 2962              }            },            newText = "prototype_type",            replace = {              end = {                character = 13,                line = 2962              },              start = {                character = 6,                line = 2962              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "additional_types",          kind = 9,          label = "additional_types",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2962              },              start = {                character = 6,                line = 2962              }            },            newText = "additional_types",            replace = {              end = {                character = 13,                line = 2962              },              start = {                character = 6,                line = 2962              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          filterText = "utility",          kind = 9,          label = "utility",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2962              },              start = {                character = 6,                line = 2962              }            },            newText = "utility",            replace = {              end = {                character = 13,                line = 2962              },              start = {                character = 6,                line = 2962              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "Extra iterator adaptors, functions and macros.\n\nTo extend [`Iterator`] with methods in this crate, import\nthe [`Itertools`] trait:\n\n```rust\nuse itertools::Itertools;\n```\n\nNow, new methods like [`interleave`](Itertools::interleave)\nare available on all iterators:\n\n```rust\nuse itertools::Itertools;\n\nlet it = (1..3).interleave(vec![-1, -2]);\nitertools::assert_equal(it, vec![1, -1, 2, -2]);\n```\n\nMost iterator methods are also provided as functions (with the benefit\nthat they convert parameters using [`IntoIterator`]):\n\n```rust\nuse itertools::interleave;\n\nfor elt in interleave(&[1, 2, 3], &[2, 3, 4]) {\n    /* loop body */\n}\n```\n\n## Crate Features\n\n- `use_std`\n  - Enabled by default.\n  - Disable to compile itertools using `#![no_std]`. This disables\n    any items that depend on collections (like `group_by`, `unique`,\n    `kmerge`, `join` and many more).\n\n## Rust Version\n\nThis version of itertools requires Rust 1.32 or later."          },          filterText = "itertools",          kind = 9,          label = "itertools",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2962              },              start = {                character = 6,                line = 2962              }            },            newText = "itertools",            replace = {              end = {                character = 13,                line = 2962              },              start = {                character = 6,                line = 2962              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "# High-level bindings to Lua\n\nThe `mlua` crate provides safe high-level bindings to the [Lua programming language].\n\n# The `Lua` object\n\nThe main type exported by this library is the [`Lua`] struct. In addition to methods for\n[executing] Lua chunks or [evaluating] Lua expressions, it provides methods for creating Lua\nvalues and accessing the table of [globals].\n\n# Converting data\n\nThe [`ToLua`] and [`FromLua`] traits allow conversion from Rust types to Lua values and vice\nversa. They are implemented for many data structures found in Rust's standard library.\n\nFor more general conversions, the [`ToLuaMulti`] and [`FromLuaMulti`] traits allow converting\nbetween Rust types and *any number* of Lua values.\n\nMost code in `mlua` is generic over implementors of those traits, so in most places the normal\nRust data structures are accepted without having to write any boilerplate.\n\n# Custom Userdata\n\nThe [`UserData`] trait can be implemented by user-defined types to make them available to Lua.\nMethods and operators to be used from Lua can be added using the [`UserDataMethods`] API.\nFields are supported using the [`UserDataFields`] API.\n\n# Serde support\n\nThe [`LuaSerdeExt`] trait implemented for [`Lua`] allows conversion from Rust types to Lua values\nand vice versa using serde. Any user defined data type that implements [`serde::Serialize`] or\n[`serde::Deserialize`] can be converted.\nFor convenience, additional functionality to handle `NULL` values and arrays is provided.\n\nThe [`Value`] enum implements [`serde::Serialize`] trait to support serializing Lua values\n(including [`UserData`]) into Rust values.\n\nRequires `feature = \"serialize\"`.\n\n# Async/await support\n\nThe [`create_async_function`] allows creating non-blocking functions that returns [`Future`].\nLua code with async capabilities can be executed by [`call_async`] family of functions or polling\n[`AsyncThread`] using any runtime (eg. Tokio).\n\nRequires `feature = \"async\"`.\n\n# `Send` requirement\nBy default `mlua` is `!Send`. This can be changed by enabling `feature = \"send\"` that adds `Send` requirement\nto [`Function`]s and [`UserData`].\n\n[Lua programming language]: https://www.lua.org/\n[`Lua`]: crate::Lua\n[executing]: crate::Chunk::exec\n[evaluating]: crate::Chunk::eval\n[globals]: crate::Lua::globals\n[`ToLua`]: crate::ToLua\n[`FromLua`]: crate::FromLua\n[`ToLuaMulti`]: crate::ToLuaMulti\n[`FromLuaMulti`]: crate::FromLuaMulti\n[`Function`]: crate::Function\n[`UserData`]: crate::UserData\n[`UserDataFields`]: crate::UserDataFields\n[`UserDataMethods`]: crate::UserDataMethods\n[`LuaSerdeExt`]: crate::LuaSerdeExt\n[`Value`]: crate::Value\n[`create_async_function`]: crate::Lua::create_async_function\n[`call_async`]: crate::Function::call_async\n[`AsyncThread`]: crate::AsyncThread\n[`Future`]: std::future::Future\n[`serde::Serialize`]: https://docs.serde.rs/serde/ser/trait.Serialize.html\n[`serde::Deserialize`]: https://docs.serde.rs/serde/de/trait.Deserialize.html"          },          filterText = "mlua",          kind = 9,          label = "mlua",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2962              },              start = {                character = 6,                line = 2962              }            },            newText = "mlua",            replace = {              end = {                character = 13,                line = 2962              },              start = {                character = 6,                line = 2962              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "# The Rust core allocation and collections library\n\nThis library provides smart pointers and collections for managing\nheap-allocated values.\n\nThis library, like libcore, normally doesn’t need to be used directly\nsince its contents are re-exported in the [`std` crate](../std/index.html).\nCrates that use the `#![no_std]` attribute however will typically\nnot depend on `std`, so they’d use this crate instead.\n\n## Boxed values\n\nThe [`Box`] type is a smart pointer type. There can only be one owner of a\n[`Box`], and the owner can decide to mutate the contents, which live on the\nheap.\n\nThis type can be sent among threads efficiently as the size of a `Box` value\nis the same as that of a pointer. Tree-like data structures are often built\nwith boxes because each node often has only one owner, the parent.\n\n## Reference counted pointers\n\nThe [`Rc`] type is a non-threadsafe reference-counted pointer type intended\nfor sharing memory within a thread. An [`Rc`] pointer wraps a type, `T`, and\nonly allows access to `&T`, a shared reference.\n\nThis type is useful when inherited mutability (such as using [`Box`]) is too\nconstraining for an application, and is often paired with the [`Cell`] or\n[`RefCell`] types in order to allow mutation.\n\n## Atomically reference counted pointers\n\nThe [`Arc`] type is the threadsafe equivalent of the [`Rc`] type. It\nprovides all the same functionality of [`Rc`], except it requires that the\ncontained type `T` is shareable. Additionally, [`Arc<T>`][`Arc`] is itself\nsendable while [`Rc<T>`][`Rc`] is not.\n\nThis type allows for shared access to the contained data, and is often\npaired with synchronization primitives such as mutexes to allow mutation of\nshared resources.\n\n## Collections\n\nImplementations of the most common general purpose data structures are\ndefined in this library. They are re-exported through the\n[standard collections library](../std/collections/index.html).\n\n## Heap interfaces\n\nThe [`alloc`](alloc/index.html) module defines the low-level interface to the\ndefault global allocator. It is not compatible with the libc allocator API.\n\n[`Arc`]: sync\n[`Box`]: boxed\n[`Cell`]: core::cell\n[`Rc`]: rc\n[`RefCell`]: core::cell"          },          filterText = "alloc",          kind = 9,          label = "alloc",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2962              },              start = {                character = 6,                line = 2962              }            },            newText = "alloc",            replace = {              end = {                character = 13,                line = 2962              },              start = {                character = 6,                line = 2962              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "This crate is not intended for use outside of [factorio-lib-rs]!"          },          filterText = "factorio_lib_rs_derive",          kind = 9,          label = "factorio_lib_rs_derive",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2962              },              start = {                character = 6,                line = 2962              }            },            newText = "factorio_lib_rs_derive",            replace = {              end = {                character = 13,                line = 2962              },              start = {                character = 6,                line = 2962              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = " Compile-time string formatting.\n\n This crate provides types and macros for formatting strings at compile-time.\n\n # Rust versions\n\n There are some features that require Rust 1.46.0,\n some that require Rust 1.51.0,\n and others that require Rust nightly,\n the sections below describe the features that are available for each version.\n\n ### Rust 1.46.0\n\n These macros are the only things available in Rust 1.46.0:\n\n - [`concatcp`]:\n Concatenates `integers`, `bool`, `char`, and `&str` constants into a `&'static str` constant.\n\n - [`formatcp`]:\n [`format`]-like formatting which takes `integers`, `bool`, `char`, and `&str` constants,\n and emits a `&'static str` constant.\n\n - [`str_get`]:\n Indexes a `&'static str` constant, returning `None` when the index is out of bounds.\n\n - [`str_index`]:\n Indexes a `&'static str` constant.\n\n - [`str_repeat`]:\n Creates a `&'static str` by repeating a `&'static str` constant `times` times.\n\n - [`str_splice`]:\n Replaces a substring in a `&'static str` constant.\n\n\n ### Rust 1.51.0\n\n By enabling the \"const_generics\" feature, you can use these macros:\n\n - [`map_ascii_case`]:\n Converts a `&'static str` constant to a different casing style,\n determined by a [`Case`] argument.\n\n - [`str_replace`]:\n Replaces all the instances of a pattern in a `&'static str` constant with\n another `&'static str` constant.\n\n ### Rust 1.57.0\n\n The \"assertcp\" feature enables the [`assertcp`], [`assertcp_eq`],\n and [`assertcp_ne`] macros.\n These macros are like the standard library assert macros,\n but evaluated at compile-time,\n with the limitation that they can only have primitive types as arguments\n (just like [`concatcp`] and [`formatcp`]).\n\n ### Rust nightly\n\n By enabling the \"fmt\" feature, you can use a [`std::fmt`]-like API.\n\n This requires the nightly compiler because it uses mutable references in const fn,\n which have not been stabilized as of writing these docs.\n\n All the other features of this crate are implemented on top of the [`const_format::fmt`] API:\n\n - [`concatc`]:\n Concatenates many standard library and user defined types into a `&'static str` constant.\n\n - [`formatc`]:\n [`format`]-like macro that can format many standard library and user defined types into\n a `&'static str` constant.\n\n - [`writec`]:\n [`write`]-like macro that can format many standard library and user defined types\n into a type that implements [`WriteMarker`].\n\n The \"derive\" feature enables the [`ConstDebug`] macro,\n and the \"fmt\" feature.<br>\n [`ConstDebug`] derives the [`FormatMarker`] trait,\n and implements an inherent `const_debug_fmt` method for compile-time debug formatting.\n\n The \"assertc\" feature enables the [`assertc`], [`assertc_eq`], [`assertc_ne`] macros,\n and the \"fmt\" feature.<br>\n These macros are like the standard library assert macros, but evaluated at compile-time.\n # Examples\n\n ### Concatenation of primitive types\n\n This example works in Rust 1.46.0.\n\n ```rust\n use const_format::concatcp;\n\n const NAME: &str = \"Bob\";\n const FOO: &str = concatcp!(NAME, \", age \", 21u8,\"!\");\n\n assert_eq!(FOO, \"Bob, age 21!\");\n ```\n\n ### Formatting primitive types\n\n This example works in Rust 1.46.0.\n\n ```rust\n use const_format::formatcp;\n\n const NAME: &str = \"John\";\n\n const FOO: &str = formatcp!(\"{NAME}, age {}!\", compute_age(NAME));\n\n assert_eq!(FOO, \"John, age 24!\");\n\n # const fn compute_age(s: &str) -> usize { s.len() * 6 }\n\n ```\n\n ### Formatting custom types\n\n This example demonstrates how you can use the [`ConstDebug`] derive macro,\n and then format the type into a `&'static str` constant.\n\n This example requires Rust nightly, and the \"derive\" feature.\n\n```rust\n #![feature(const_mut_refs)]\n\n use const_format::{ConstDebug, formatc};\n\n #[derive(ConstDebug)]\n struct Message{\n     ip: [Octet; 4],\n     value: &'static str,\n }\n\n #[derive(ConstDebug)]\n struct Octet(u8);\n\n const MSG: Message = Message{\n     ip: [Octet(127), Octet(0), Octet(0), Octet(1)],\n     value: \"Hello, World!\",\n };\n\n const FOO: &str = formatc!(\"{:?}\", MSG);\n\n assert_eq!(\n     FOO,\n     \"Message { ip: [Octet(127), Octet(0), Octet(0), Octet(1)], value: \\\"Hello, World!\\\" }\"\n );\n\n ```\n\n## Formatted const assertions\n\n This example demonstrates how you can use the [`assertcp_ne`] macro to\n do compile-time inequality assertions with formatted error messages.\n\n This requires the \"assertcp\" feature,\n because using the `panic` macro at compile-time requires Rust 1.57.0.\n\n```ignore\n #![feature(const_mut_refs)]\n\n use const_format::assertcp_ne;\n\n macro_rules! check_valid_pizza{\n     ($user:expr, $topping:expr) => {\n         assertcp_ne!(\n             $topping,\n             \"pineapple\",\n             \"You can't put pineapple on pizza, {}\",\n             $user,\n         );\n     }\n }\n\n check_valid_pizza!(\"John\", \"salami\");\n check_valid_pizza!(\"Dave\", \"sausage\");\n check_valid_pizza!(\"Bob\", \"pineapple\");\n\n # fn main(){}\n ```\n\n This is the compiler output:\n\n ```text\n error[E0080]: evaluation of constant value failed\n   --> src/lib.rs:178:27\n    |\n 20 | check_valid_pizza!(\"Bob\", \"pineapple\");\n    |                           ^^^^^^^^^^^ the evaluated program panicked at '\n assertion failed: `(left != right)`\n  left: `\"pineapple\"`\n right: `\"pineapple\"`\n You can't put pineapple on pizza, Bob\n ', src/lib.rs:20:27\n\n\n ```\n\n <div id=\"macro-limitations\"></div>\n\n # Limitations\n\n All of the macros from `const_format` have these limitations:\n\n - The formatting macros that expand to\n `&'static str`s can only use constants from concrete types,\n so while a `Type::<u8>::FOO` argument would be fine,\n `Type::<T>::FOO` would not be (`T` being a type parameter).\n\n - Integer arguments must have a type inferrable from context,\n [more details in the Integer arguments section](#integer-args).\n\n - They cannot be used places that take string literals.\n So `#[doc = \"foobar\"]` cannot be replaced with `#[doc = concatcp!(\"foo\", \"bar\") ]`.\n\n <span id=\"integer-args\"></span>\n\n ### Integer arguments\n\n Integer arguments must have a type inferrable from context.\n so if you only pass an integer literal it must have a suffix.\n\n Example of what does compile:\n\n ```rust\n const N: u32 = 1;\n assert_eq!(const_format::concatcp!(N + 1, 2 + N), \"23\");\n\n assert_eq!(const_format::concatcp!(2u32, 2 + 1u8, 3u8 + 1), \"234\");\n ```\n\n Example of what does not compile:\n ```compile_fail\n assert_eq!(const_format::concatcp!(1 + 1, 2 + 1), \"23\");\n ```\n\n # Renaming crate\n\n All function-like macros from `const_format` can be used when the crate is renamed.\n\n The [`ConstDebug`] derive macro has the `#[cdeb(crate = \"foo::bar\")]` attribute to\n tell it where to find the `const_format` crate.\n\n Example of renaming the `const_format` crate in the Cargo.toml file:\n ```toml\n cfmt = {version = \"0.*\", package = \"const_format\"}\n ```\n\n # Cargo features\n\n - \"fmt\": Enables the [`std::fmt`]-like API,\n requires Rust nightly because it uses mutable references in const fn.<br>\n This feature includes the [`formatc`]/[`writec`] formatting macros.\n\n - \"derive\": implies the \"fmt\" feature,\n provides the [`ConstDebug`] derive macro to format user-defined types at compile-time.<br>\n This implicitly uses the `syn` crate, so clean compiles take a bit longer than without the feature.\n\n - \"assertc\": implies the \"fmt\" feature,\n enables the [`assertc`], [`assertc_eq`], and [`assertc_ne`] assertion macros.<br>\n This feature was previously named \"assert\",\n but it was renamed to avoid confusion with the \"assertcp\" feature.\n\n - \"assertcp\": Requires Rust 1.57.0, implies the \"const_generics\" feature.\n Enables the [`assertcp`], [`assertcp_eq`], and [`assertcp_ne`] assertion macros.\n\n - \"constant_time_as_str\": implies the \"fmt\" feature.\n An optimization that requires a few additional nightly features,\n allowing the `as_bytes_alt` methods and `slice_up_to_len_alt` methods to run\n in constant time, rather than linear time proportional to the truncated part of the slice.\n\n - \"const_generics\": Requires Rust 1.51.0.\n Enables the macros listed in the [Rust 1.51.0](#rust-1510) section.\n Also changes the the implementation of the [`concatcp`] and [`formatcp`]\n macros to use const generics.\n\n\n\n # No-std support\n\n `const_format` is unconditionally `#![no_std]`, it can be used anywhere Rust can be used.\n\n # Minimum Supported Rust Version\n\n `const_format` requires Rust 1.46.0, because it uses looping an branching in const contexts.\n\n Features that require newer versions of Rust, or the nightly compiler,\n need to be explicitly enabled with cargo features.\n\n\n [`assertc`]: ./macro.assertc.html\n\n [`assertc_eq`]: ./macro.assertc_eq.html\n\n [`assertc_ne`]: ./macro.assertc_ne.html\n\n [`assertcp`]: ./macro.assertcp.html\n\n [`assertcp_eq`]: ./macro.assertcp_eq.html\n\n [`assertcp_ne`]: ./macro.assertcp_ne.html\n\n [`concatcp`]: ./macro.concatcp.html\n\n [`formatcp`]: ./macro.formatcp.html\n\n [`format`]: https://doc.rust-lang.org/std/macro.format.html\n\n [`std::fmt`]: https://doc.rust-lang.org/std/fmt/index.html\n\n [`const_format::fmt`]: ./fmt/index.html\n\n [`concatc`]: ./macro.concatc.html\n\n [`formatc`]: ./macro.formatc.html\n\n [`writec`]: ./macro.writec.html\n\n [`write`]: https://doc.rust-lang.org/std/macro.write.html\n\n [`Formatter`]: ./fmt/struct.Formatter.html\n\n [`StrWriter`]: ./fmt/struct.StrWriter.html\n\n [`ConstDebug`]: ./derive.ConstDebug.html\n\n [`FormatMarker`]: ./marker_traits/trait.FormatMarker.html\n\n [`WriteMarker`]: ./marker_traits/trait.WriteMarker.html\n\n [`map_ascii_case`]: ./macro.map_ascii_case.html\n\n [`Case`]: ./enum.Case.html\n\n\n [`str_get`]: ./macro.str_get.html\n\n [`str_index`]: ./macro.str_index.html\n\n [`str_repeat`]: ./macro.str_repeat.html\n\n [`str_splice`]: ./macro.str_splice.html\n\n [`str_replace`]: ./macro.str_replace.html\n\n [`str::replace`]: https://doc.rust-lang.org/std/primitive.str.html#method.replace"          },          filterText = "const_format",          kind = 9,          label = "const_format",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2962              },              start = {                character = 6,                line = 2962              }            },            newText = "const_format",            replace = {              end = {                character = 13,                line = 2962              },              start = {                character = 6,                line = 2962              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = 'Ini parser for Rust\n\n```rust\nuse ini::Ini;\n\nlet mut conf = Ini::new();\nconf.with_section(Some("User"))\n    .set("name", "Raspberry树莓")\n    .set("value", "Pi");\nconf.with_section(Some("Library"))\n    .set("name", "Sun Yat-sen U")\n    .set("location", "Guangzhou=world");\nconf.write_to_file("conf.ini").unwrap();\n\nlet i = Ini::load_from_file("conf.ini").unwrap();\nfor (sec, prop) in i.iter() {\n    println!("Section: {:?}", sec);\n    for (k, v) in prop.iter() {\n        println!("{}:{}", k, v);\n    }\n}\n```'          },          filterText = "ini",          kind = 9,          label = "ini",          preselect = true,          sortText = "ffffffef",          textEdit = {            insert = {              end = {                character = 7,                line = 2962              },              start = {                character = 6,                line = 2962              }            },            newText = "ini",            replace = {              end = {                character = 13,                line = 2962              },              start = {                character = 6,                line = 2962              }            }          }        }, {          additionalTextEdits = {},          deprecated = false,          documentation = {            kind = "markdown",            value = "\nThis crate provides a library for parsing, compiling, and executing regular\nexpressions. Its syntax is similar to Perl-style regular expressions, but lacks\na few features like look around and backreferences. In exchange, all searches\nexecute in linear time with respect to the size of the regular expression and\nsearch text.\n\nThis crate's documentation provides some simple examples, describes\n[Unicode support](#unicode) and exhaustively lists the\n[supported syntax](#syntax).\n\nFor more specific details on the API for regular expressions, please see the\ndocumentation for the [`Regex`](struct.Regex.html) type.\n\n# Usage\n\nThis crate is [on crates.io](https://crates.io/crates/regex) and can be\nused by adding `regex` to your dependencies in your project's `Cargo.toml`.\n\n```toml\n[dependencies]\nregex = \"1\"\n```\n\n# Example: find a date\n\nGeneral use of regular expressions in this package involves compiling an\nexpression and then using it to search, split or replace text. For example,\nto confirm that some text resembles a date:\n\n```rust\nuse regex::Regex;\nlet re = Regex::new(r\"^\\d{4}-\\d{2}-\\d{2}$\").unwrap();\nassert!(re.is_match(\"2014-01-01\"));\n```\n\nNotice the use of the `^` and `$` anchors. In this crate, every expression\nis executed with an implicit `.*?` at the beginning and end, which allows\nit to match anywhere in the text. Anchors can be used to ensure that the\nfull text matches an expression.\n\nThis example also demonstrates the utility of\n[raw strings](https://doc.rust-lang.org/stable/reference/tokens.html#raw-string-literals)\nin Rust, which\nare just like regular strings except they are prefixed with an `r` and do\nnot process any escape sequences. For example, `\"\\\\d\"` is the same\nexpression as `r\"\\d\"`.\n\n# Example: Avoid compiling the same regex in a loop\n\nIt is an anti-pattern to compile the same regular expression in a loop\nsince compilation is typically expensive. (It takes anywhere from a few\nmicroseconds to a few **milliseconds** depending on the size of the\nregex.) Not only is compilation itself expensive, but this also prevents\noptimizations that reuse allocations internally to the matching engines.\n\nIn Rust, it can sometimes be a pain to pass regular expressions around if\nthey're used from inside a helper function. Instead, we recommend using the\n[`lazy_static`](https://crates.io/crates/lazy_static) crate to ensure that\nregular expressions are compiled exactly once.\n\nFor example:\n\n```rust\nuse lazy_static::lazy_static;\nuse regex::Regex;\n\nfn some_helper_function(text: &str) -> bool {\n    lazy_static! {\n        static ref RE: Regex = Regex::new(\"...\").unwrap();\n    }\n    RE.is_match(text)\n}\n\nfn main() {}\n```\n\nSpecifically, in this example, the regex will be compiled when it is used for\nthe first time. On subsequent uses, it will reuse the previous compilation.\n\n# Example: iterating over capture groups\n\nThis crate provides convenient iterators for matching an expression\nrepeatedly against a search string to find successive non-overlapping\nmatches. For example, to find all dates in a string and be able to access\nthem by their component pieces:\n\n```rust\nlet re = Regex::new(r\"(\\d{4})-(\\d{2})-(\\d{2})\").unwrap();\nlet text = \"2012-03-14, 2013-01-01 and 2014-07-05\";\nfor cap in re.captures_iter(text) {\n    println!(\"Month: {} Day: {} Year: {}\", &cap[2], &cap[3], &cap[1]);\n}\n// Output:\n// Month: 03 Day: 14 Year: 2012\n// Month: 01 Day: 01 Year: 2013\n// Month: 07 Day: 05 Year: 2014\n```\n\nNotice that the year is in the capture group indexed at `1`. This is\nbecause the *entire match* is stored in the capture group at index `0`.\n\n# Example: replacement with named capture groups\n\nBuilding on the previous example, perhaps we'd like to rearrange the date\nformats. This can be done with text replacement. But to make the code\nclearer, we can *name*  our capture groups and use those names as variables\nin our replacement text:\n\n```rust\nlet re = Regex::new(r\"(?P<y>\\d{4})-(?P<m>\\d{2})-(?P<d>\\d{2})\").unwrap();\nlet before = \"2012-03-14, 2013-01-01 and 2014-07-05\";\nlet after = re.replace_all(before, \"$m/$d/$y\");\nassert_eq!(after, \"03/14/2012, 01/01/2013 and 07/05/2014\");\n```\n\nThe `replace` methods are actually polymorphic in the replacement, which\nprovides more flexibility than is seen here. (See the documentation for\n`Regex::replace` for more details.)\n\nNote that if your regex gets complicated, you can use the `x` flag to\nenable insignificant whitespace mode, which also lets you write comments:\n\n```rust\nlet re = Regex::new(r\"(?x)\n  (?P<y>\\d{4}) # the year\n  -\n  (?P<m>\\d{2}) # the month\n  -\n  (?P<d>\\d{2}) # the day\n\").unwrap();\nlet before = \"2012-03-14, 2013-01-01 and 2014-07-05\";\nlet after = re.replace_all(before, \"$m/$d/$y\");\nassert_eq!(after, \"03/14/2012, 01/01/2013 and 07/05/2014\");\n```\n\nIf you wish to match against whitespace in this mode, you can still use `\\s`,\n`\\n`, `\\t`, etc. For escaping a single space character, you can escape it\ndirectly with `\\ `, use its hex character code `\\x20` or temporarily disable\nthe `x` flag, e.g., `(?-x: )`.\n\n# Example: match multiple regular expressions simultaneously\n\nThis demonstrates how to use a `RegexSet` to match multiple (possibly\noverlapping) regular expressions in a single scan of the search text:\n\n```rust\nuse regex::RegexSet;\n\nlet set = RegexSet::new(&[\n    r\"\\w+\",\n    r\"\\d+\",\n    r\"\\pL+\",\n    r\"foo\",\n    r\"bar\",\n    r\"barfoo\",\n    r\"foobar\",\n]).unwrap();\n\n// Iterate over and collect all of the matches.\nlet matches: Vec<_> = set.matches(\"foobar\").into_iter().collect();\nassert_eq!(matches, vec![0, 2, 3, 4, 6]);\n\n// You can also test whether a particular regex matched:\nlet matches = set.matches(\"foobar\");\nassert!(!matches.matched(5));\nassert!(matches.matched(6));\n```\n\n# Pay for what you use\n\nWith respect to searching text with a regular expression, there are three\nquestions that can be asked:\n\n1. Does the text match this expression?\n2. If so, where does it match?\n3. Where did the capturing groups match?\n\nGenerally speaking, this crate could provide a function to answer only #3,\nwhich would subsume #1 and #2 automatically. However, it can be significantly\nmore expensive to compute the location of capturing group matches, so it's best\nnot to do it if you don't need to.\n\nTherefore, only use what you need. For example, don't use `find` if you\nonly need to test if an expression matches a string. (Use `is_match`\ninstead.)\n\n# Unicod