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