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