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