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