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