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