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