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