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