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