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