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