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