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