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