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