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