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