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