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