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