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