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