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