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