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