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