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