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