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