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