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